Skip to content

Commit a19fc77

Browse files
netramalinetramali
committed
add nullable relationship
1 parent 0f6f733 commit a19fc77

File tree

6 files changed

+354
-13
lines changed

6 files changed

+354
-13
lines changed

‎models_test.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ type WithNullableAttrs struct {
4242
RFC3339Time NullableAttr[time.Time] `jsonapi:"attr,rfc3339_time,rfc3339,omitempty"`
4343
ISO8601Time NullableAttr[time.Time] `jsonapi:"attr,iso8601_time,iso8601,omitempty"`
4444
Bool NullableAttr[bool] `jsonapi:"attr,bool,omitempty"`
45+
NullableComment NullableRelationship[*Comment] `jsonapi:"relation,nullable_comment,omitempty"`
4546
}
4647

4748
type Car struct {

‎nullable.go‎

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,35 @@ import (
2626
// Adapted from https://www.jvt.me/posts/2024/01/09/go-json-nullable/
2727
type NullableAttr[T any] map[bool]T
2828

29+
// NullableRelationship is a generic type, which implements a field that can be one of three states:
30+
//
31+
// - relationship is not set in the request
32+
// - relationship is explicitly set to `null` in the request
33+
// - relationship is explicitly set to a valid relationship value in the request
34+
//
35+
// NullableRelationship is intended to be used with JSON marshalling and unmarshalling.
36+
// This is generally useful for PATCH requests, where relationships with zero
37+
// values are intentionally not marshaled into the request payload so that
38+
// existing attribute values are not overwritten.
39+
//
40+
// Internal implementation details:
41+
//
42+
// - map[true]T means a value was provided
43+
// - map[false]T means an explicit null was provided
44+
// - nil or zero map means the field was not provided
45+
//
46+
// If the relationship is expected to be optional, add the `omitempty` JSON tags. Do NOT use `*NullableRelationship`!
47+
//
48+
// Slice types are not currently supported for NullableRelationships as the nullable nature can be expressed via empty array
49+
// `polyrelation` JSON tags are NOT currently supported.
50+
//
51+
// NullableRelationships must have an inner type of pointer:
52+
//
53+
// - NullableRelationship[*Comment] - valid
54+
// - NullableRelationship[[]*Comment] - invalid
55+
// - NullableRelationship[Comment] - invalid
56+
type NullableRelationship[T any] map[bool]T
57+
2958
// NewNullableAttrWithValue is a convenience helper to allow constructing a
3059
// NullableAttr with a given value, for instance to construct a field inside a
3160
// struct without introducing an intermediate variable.
@@ -87,3 +116,65 @@ func (t NullableAttr[T]) IsSpecified() bool {
87116
func (t *NullableAttr[T]) SetUnspecified() {
88117
*t = map[bool]T{}
89118
}
119+
120+
// NewNullableAttrWithValue is a convenience helper to allow constructing a
121+
// NullableAttr with a given value, for instance to construct a field inside a
122+
// struct without introducing an intermediate variable.
123+
func NewNullableRelationshipWithValue[T any](t T) NullableRelationship[T] {
124+
var n NullableRelationship[T]
125+
n.Set(t)
126+
return n
127+
}
128+
129+
// NewNullNullableAttr is a convenience helper to allow constructing a NullableAttr with
130+
// an explicit `null`, for instance to construct a field inside a struct
131+
// without introducing an intermediate variable
132+
func NewNullNullableRelationship[T any]() NullableRelationship[T] {
133+
var n NullableRelationship[T]
134+
n.SetNull()
135+
return n
136+
}
137+
138+
// Get retrieves the underlying value, if present, and returns an error if the value was not present
139+
func (t NullableRelationship[T]) Get() (T, error) {
140+
var empty T
141+
if t.IsNull() {
142+
return empty, errors.New("value is null")
143+
}
144+
if !t.IsSpecified() {
145+
return empty, errors.New("value is not specified")
146+
}
147+
return t[true], nil
148+
}
149+
150+
// Set sets the underlying value to a given value
151+
func (t *NullableRelationship[T]) Set(value T) {
152+
*t = map[bool]T{true: value}
153+
}
154+
155+
// Set sets the underlying value to a given value
156+
func (t *NullableRelationship[T]) SetInterface(value interface{}) {
157+
t.Set(value.(T))
158+
}
159+
160+
// IsNull indicates whether the field was sent, and had a value of `null`
161+
func (t NullableRelationship[T]) IsNull() bool {
162+
_, foundNull := t[false]
163+
return foundNull
164+
}
165+
166+
// SetNull sets the value to an explicit `null`
167+
func (t *NullableRelationship[T]) SetNull() {
168+
var empty T
169+
*t = map[bool]T{false: empty}
170+
}
171+
172+
// IsSpecified indicates whether the field was sent
173+
func (t NullableRelationship[T]) IsSpecified() bool {
174+
return len(t) != 0
175+
}
176+
177+
// SetUnspecified sets the value to be absent from the serialized payload
178+
func (t *NullableRelationship[T]) SetUnspecified() {
179+
*t = map[bool]T{}
180+
}

‎request.go‎

Lines changed: 36 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -483,10 +483,30 @@ func unmarshalNode(data *Node, model reflect.Value, included *map[string]*Node)
483483

484484
buf := bytes.NewBuffer(nil)
485485

486-
json.NewEncoder(buf).Encode(
487-
data.Relationships[args[1]],
488-
)
489-
json.NewDecoder(buf).Decode(relationship)
486+
relDataStr := data.Relationships[args[1]]
487+
json.NewEncoder(buf).Encode(relDataStr)
488+
489+
isExplicitNull := false
490+
relationshipDecodeErr := json.NewDecoder(buf).Decode(relationship)
491+
if relationshipDecodeErr == nil && relationship.Data == nil {
492+
// If the relationship was a valid node and relationship data was null
493+
// this indicates disassociating the relationship
494+
isExplicitNull = true
495+
} else if relationshipDecodeErr != nil {
496+
er = fmt.Errorf("decode err %v\n", relationshipDecodeErr)
497+
}
498+
499+
// This will hold either the value of the choice type model or the actual
500+
// model, depending on annotation
501+
m := reflect.New(fieldValue.Type().Elem())
502+
503+
// Nullable relationships have an extra pointer indirection
504+
// unwind that here
505+
if strings.HasPrefix(fieldType.Type.Name(), "NullableRelationship[") {
506+
if m.Kind() == reflect.Ptr {
507+
m = reflect.New(fieldValue.Type().Elem().Elem())
508+
}
509+
}
490510

491511
/*
492512
http://jsonapi.org/format/#document-resource-object-relationships
@@ -495,6 +515,12 @@ func unmarshalNode(data *Node, model reflect.Value, included *map[string]*Node)
495515
so unmarshal and set fieldValue only if data obj is not null
496516
*/
497517
if relationship.Data == nil {
518+
// Explicit null supplied for the field value
519+
// If a nullable relationship we set the field value to a map with a single entry
520+
if isExplicitNull {
521+
fieldValue.Set(reflect.MakeMapWithSize(fieldValue.Type(), 1))
522+
fieldValue.SetMapIndex(reflect.ValueOf(false), m)
523+
}
498524
continue
499525
}
500526

@@ -505,17 +531,19 @@ func unmarshalNode(data *Node, model reflect.Value, included *map[string]*Node)
505531
continue
506532
}
507533

508-
// This will hold either the value of the choice type model or the actual
509-
// model, depending on annotation
510-
m := reflect.New(fieldValue.Type().Elem())
511534

512535
err = unmarshalNodeMaybeChoice(&m, relationship.Data, annotation, choiceMapping, included)
513536
if err != nil {
514537
er = err
515538
break
516539
}
517540

518-
fieldValue.Set(m)
541+
if strings.HasPrefix(fieldType.Type.Name(), "NullableRelationship[") {
542+
fieldValue.Set(reflect.MakeMapWithSize(fieldValue.Type(), 1))
543+
fieldValue.SetMapIndex(reflect.ValueOf(true), m)
544+
} else {
545+
fieldValue.Set(m)
546+
}
519547
}
520548
} else if annotation == annotationLinks {
521549
if data.Links == nil {

‎request_test.go‎

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import (
88
"io"
99
"reflect"
1010
"sort"
11+
"strconv"
1112
"strings"
1213
"testing"
1314
"time"
@@ -382,6 +383,127 @@ func TestUnmarshalNullableBool(t *testing.T) {
382383
}
383384
}
384385

386+
func TestUnmarshalNullableRelationshipsNonNullValue(t *testing.T) {
387+
comment := &Comment{
388+
ID: 5,
389+
Body: "Hello World",
390+
}
391+
392+
payload := &OnePayload{
393+
Data: &Node{
394+
ID: "10",
395+
Type: "with-nullables",
396+
Relationships: map[string]interface{}{
397+
"nullable_comment": &RelationshipOneNode{
398+
Data: &Node{
399+
Type: "comments",
400+
ID: strconv.Itoa(comment.ID),
401+
},
402+
},
403+
},
404+
},
405+
}
406+
407+
outBuf := bytes.NewBuffer(nil)
408+
json.NewEncoder(outBuf).Encode(payload)
409+
410+
out := new(WithNullableAttrs)
411+
412+
if err := UnmarshalPayload(outBuf, out); err != nil {
413+
t.Fatal(err)
414+
}
415+
416+
nullableCommentOpt := out.NullableComment
417+
if !nullableCommentOpt.IsSpecified() {
418+
t.Fatal("Expected NullableComment to be specified")
419+
}
420+
421+
nullableComment, err := nullableCommentOpt.Get()
422+
if err != nil {
423+
t.Fatal(err)
424+
}
425+
426+
if expected, actual := comment.ID, nullableComment.ID; expected != actual {
427+
t.Fatalf("Was expecting NullableComment to be `%d`, got `%d`", expected, actual)
428+
}
429+
}
430+
431+
func TestUnmarshalNullableRelationshipsExplicitNullValue(t *testing.T) {
432+
payload := &OnePayload{
433+
Data: &Node{
434+
ID: "10",
435+
Type: "with-nullables",
436+
Relationships: map[string]interface{}{
437+
"nullable_comment": &RelationshipOneNode{
438+
Data: nil,
439+
},
440+
},
441+
},
442+
}
443+
444+
outBuf := bytes.NewBuffer(nil)
445+
json.NewEncoder(outBuf).Encode(payload)
446+
447+
out := new(WithNullableAttrs)
448+
449+
if err := UnmarshalPayload(outBuf, out); err != nil {
450+
t.Fatal(err)
451+
}
452+
453+
nullableCommentOpt := out.NullableComment
454+
if !nullableCommentOpt.IsSpecified() || !nullableCommentOpt.IsNull() {
455+
t.Fatal("Expected NullableComment to be specified and explicit null")
456+
}
457+
458+
}
459+
460+
func TestUnmarshalNullableRelationshipsNonExistentValue(t *testing.T) {
461+
payload := &OnePayload{
462+
Data: &Node{
463+
ID: "10",
464+
Type: "with-nullables",
465+
Relationships: map[string]interface{}{},
466+
},
467+
}
468+
469+
outBuf := bytes.NewBuffer(nil)
470+
json.NewEncoder(outBuf).Encode(payload)
471+
472+
out := new(WithNullableAttrs)
473+
474+
if err := UnmarshalPayload(outBuf, out); err != nil {
475+
t.Fatal(err)
476+
}
477+
478+
nullableCommentOpt := out.NullableComment
479+
if nullableCommentOpt.IsSpecified() || nullableCommentOpt.IsNull() {
480+
t.Fatal("Expected NullableComment to NOT be specified and NOT be explicit null")
481+
}
482+
}
483+
484+
func TestUnmarshalNullableRelationshipsNoRelationships(t *testing.T) {
485+
payload := &OnePayload{
486+
Data: &Node{
487+
ID: "10",
488+
Type: "with-nullables",
489+
},
490+
}
491+
492+
outBuf := bytes.NewBuffer(nil)
493+
json.NewEncoder(outBuf).Encode(payload)
494+
495+
out := new(WithNullableAttrs)
496+
497+
if err := UnmarshalPayload(outBuf, out); err != nil {
498+
t.Fatal(err)
499+
}
500+
501+
nullableCommentOpt := out.NullableComment
502+
if nullableCommentOpt.IsSpecified() || nullableCommentOpt.IsNull() {
503+
t.Fatal("Expected NullableComment to NOT be specified and NOT be explicit null")
504+
}
505+
}
506+
385507
func TestMalformedTag(t *testing.T) {
386508
out := new(BadModel)
387509
err := UnmarshalPayload(samplePayload(), out)

‎response.go‎

Lines changed: 22 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,7 @@ func visitModelNodeAttribute(args []string, node *Node, fieldValue reflect.Value
241241
node.Attributes = make(map[string]interface{})
242242
}
243243

244-
// Handle Nullable[T]
244+
// Handle NullableAttr[T]
245245
if strings.HasPrefix(fieldValue.Type().Name(), "NullableAttr[") {
246246
// handle unspecified
247247
if fieldValue.IsNil() {
@@ -353,6 +353,27 @@ func visitModelNodeRelation(model any, annotation string, args []string, node *N
353353
omitEmpty = args[2] == annotationOmitEmpty
354354
}
355355

356+
if node.Relationships == nil {
357+
node.Relationships = make(map[string]interface{})
358+
}
359+
360+
// Handle NullableRelationship[T]
361+
if strings.HasPrefix(fieldValue.Type().Name(), "NullableRelationship[") {
362+
363+
if fieldValue.MapIndex(reflect.ValueOf(false)).IsValid() {
364+
innerTypeIsSlice := fieldValue.MapIndex(reflect.ValueOf(false)).Type().Kind() == reflect.Slice
365+
// handle explicit null
366+
if innerTypeIsSlice {
367+
node.Relationships[args[1]] = json.RawMessage("[]")
368+
} else {
369+
node.Relationships[args[1]] = json.RawMessage("{\"data\":null}")
370+
}
371+
} else if fieldValue.MapIndex(reflect.ValueOf(true)).IsValid() {
372+
// handle value
373+
fieldValue = fieldValue.MapIndex(reflect.ValueOf(true))
374+
}
375+
}
376+
356377
isSlice := fieldValue.Type().Kind() == reflect.Slice
357378
if omitEmpty &&
358379
(isSlice && fieldValue.Len() < 1 ||
@@ -417,10 +438,6 @@ func visitModelNodeRelation(model any, annotation string, args []string, node *N
417438
}
418439
}
419440

420-
if node.Relationships == nil {
421-
node.Relationships = make(map[string]interface{})
422-
}
423-
424441
var relLinks *Links
425442
if linkableModel, ok := model.(RelationshipLinkable); ok {
426443
relLinks = linkableModel.JSONAPIRelationshipLinks(args[1])

0 commit comments

Comments
 (0)