Ben KraftandGitHub
65c3e20ee6
## Summary:
There were a few bugs here, one of which Craig came across when pulling
the custom-unmarshaler change into webapp:
1. If you have an optional field with a custom unmarshaler, and the
server omits the field from the response entirely (i.e. does not
write `"myField": null`), we would still call your unmarshaler with
an input of `[]byte(nil)`. This is just wrong; it's our job to do
the nil-check. (This is the one Craig found; in practice gqlgen
servers do not do this and I think the spec says not to although it's
a bit fuzzy on the matter of serialization. But in practice we have
mocks that do it -- for required fields even! -- and it seems better
to handle it than pass you data on which you'll probably err or even
panic.)
2. If you have an optional field with a custom unmarshaler, and the
server returns an explicit null (i.e. `"myField": null`), we would
call your unmarshaler with `[]byte("null")`. In principle the intent
was you're supposed to implement that, as [`json.Unmarshaler`
advises][1]. But (a) I forgot to document that, and (b) in practice
`json.Unmarshal` [does *not* call you in that case][2], i.e. its
advice is unnecessary. So I think it's better for us to just match
it, and not call you. (And in that case I see no reason to bother
documenting the advice.)
3. If you have an optional, `pointer: true` field with a custom
marshaler, the reverse of (2) applies: if the pointer is nil, we
shouldn't really call you. (Indeed if you were a real
`json.Marshaler` with a value-method rather than a pointer-method,
trying to call you might panic!) Note we don't need to explicitly
write "null"; we just leave the `json.RawMessage` as nil, and
`json.Marshal` [handles that][3].
4. We handle interface types effectively the same as custom
unmarshalers, just we generate the unmarshaler. So if you have an
optional field with interface type, (1) would also apply there; our
generated unmarshaler returns an error in this case.
5. While (2) doesn't apply to such optional interface fields (because we
do the customary `if string(b) == "null"` check -- this I at least
thought to test), if you set `pointer: true` on the field, we would
still call the unmarshaler on the value, and it would no-op, but only
*after* we initialized the pointer. Put more simply, we'd return a
non-nil pointer to nil interface, rather than a nil pointer; this is
wrong since the whole point of `pointer: true` is you only get a
non-nil pointer if your value is nil! Of course, in practice there's
little reason to use `pointer: true` on interface fields, and indeed
this stuff gets so confusing my test was even wrong.
In this commit I fix all the bugs, by adding appropriate nil-checks to
wrap the unmarshaler-calls. The templates are, as always, a bit
confusing, but the generated code makes it clear what changed.
Note we'll want to land this before cutting a release with custom
marshaler/unmarshaler support, because the first three bugs are
potentially quite noticeable. (The latter two are in `v0.1.0`, but
presumably quite rare.)
[1]: https://pkg.go.dev/encoding/json#Unmarshaler
[2]: https://play.golang.org/p/Pw6zNN8trGO
[3]: https://play.golang.org/p/crTfnT7ePte
Issue: https://phabricator.khanacademy.org/D74453#inline-558571
## Test plan:
make tesc
Author: benjaminjkraft
Reviewers: csilvers, StevenACoffman, benjaminjkraft, aberkan, dnerdy, jvoll, mahtabsabet, MiguelCastillo
Required Reviewers:
Approved By: csilvers, StevenACoffman
Checks: ✅ Test (1.17), ✅ Test (1.16), ✅ Test (1.15), ✅ Test (1.14), ✅ Lint, ✅ Test (1.17), ✅ Test (1.16), ✅ Test (1.15), ✅ Test (1.14), ✅ Lint
Pull Request URL: https://github.com/Khan/genqlient/pull/116
62 lines
2.5 KiB
Cheetah
62 lines
2.5 KiB
Cheetah
{{/* See unmarshal.go.tmpl for more on how this works; this is mostly just
|
|
parallel (and simplified -- we don't need to handle embedding). */}}
|
|
|
|
func (v *{{.GoName}}) MarshalJSON() ([]byte, error) {
|
|
{{/* We do the two passes in the opposite order of unmarshal: first, we
|
|
marshal the special fields, then we assign those to the wrapper struct
|
|
and finish marshaling the whole object. But first we set up the
|
|
object for the second part, so we can assign to it as we go. */}}
|
|
var fullObject struct{
|
|
*{{.GoName}}
|
|
{{range .Fields -}}
|
|
{{if .NeedsMarshaler -}}
|
|
{{.GoName}} {{repeat .GoType.SliceDepth "[]"}}{{ref "encoding/json.RawMessage"}} `json:"{{.JSONName}}"`
|
|
{{end -}}
|
|
{{end -}}
|
|
{{ref "github.com/Khan/genqlient/graphql.NoMarshalJSON"}}
|
|
}
|
|
fullObject.{{.GoName}} = v
|
|
|
|
{{range $field := .Fields -}}
|
|
{{if $field.NeedsMarshaler -}}
|
|
{
|
|
{{/* Here dst is the json.RawMessage, and src is the Go type */}}
|
|
dst := &fullObject.{{$field.GoName}}
|
|
src := v.{{$field.GoName}}
|
|
{{range $i := intRange $field.GoType.SliceDepth -}}
|
|
*dst = make(
|
|
{{repeat (sub $field.GoType.SliceDepth $i) "[]"}}{{ref "encoding/json.RawMessage"}},
|
|
len(src))
|
|
for i, src := range src {
|
|
dst := &(*dst)[i]
|
|
{{end -}}
|
|
{{/* src now has type <GoType>; dst is json.RawMessage */ -}}
|
|
{{if $field.GoType.IsPointer -}}
|
|
{{/* If you passed a pointer, and it's nil, don't call the
|
|
marshaler. This matches json.Marshal's behavior. */ -}}
|
|
if src != nil {
|
|
{{end -}}
|
|
var err error
|
|
*dst, err = {{$field.Marshaler $.Generator}}(
|
|
{{/* src is the struct-field (or field-element, etc.).
|
|
We want to pass a pointer to the type you specified, so if
|
|
there's a pointer on the field that's exactly what we want,
|
|
and if not we need to take the address. */ -}}
|
|
{{if not $field.GoType.IsPointer}}&{{end}}src)
|
|
if err != nil {
|
|
return nil, fmt.Errorf(
|
|
"Unable to marshal {{$.GoName}}.{{$field.GoName}}: %w", err)
|
|
}
|
|
{{if $field.GoType.IsPointer -}}
|
|
}{{/* end if src != nil */}}
|
|
{{end -}}
|
|
{{range $i := intRange $field.GoType.SliceDepth -}}
|
|
}
|
|
{{end -}}
|
|
}
|
|
{{end -}}
|
|
{{end}}
|
|
|
|
return {{ref "encoding/json.Marshal"}}(&fullObject)
|
|
}
|