@ -1,7 +1,7 @@
{{/*
{{/*
Resolves the `allOf` keyword (https://spec.openapis.org/oas/v3.1.0#composition-and-inheritance-polymorphism),
Resolves the `allOf` keyword (https://spec.openapis.org/oas/v3.1.0#composition-and-inheritance-polymorphism)
given a JSON schema object.
recursively, given a JSON schema object.
`allOf` is used to support a kind of inheritance for JSON schema objects.
`allOf` is used to support a kind of inheritance for JSON schema objects.
@ -11,92 +11,85 @@
Of course the parent can itself inherit from *its* parent, so we recurse to
Of course the parent can itself inherit from *its* parent, so we recurse to
handle that.
handle that.
Note that `allOf` is only resolved at the top level of the schema object. For
example, if you call this on an API definition which defines a `parameter`
which has an allOf schema, it will not be resolved. To handle this, the
openapi templates call resolve-allof for every schema object that they
process.
*/}}
*/}}
{{ $ret := . }}
{{ $ret := . }}
{{ $original := . }}
{{ $original := . }}
{{/*
{{ if reflect.IsSlice $ret }}
We special-case 'required', and accumulate the values from all the 'allOf'
entries (rather than simply overriding them). Start the accumulation here.
*/}}
{{ $required := .required }}
{{ if not $required }}
{{ $required := slice }}
{{ end }}
{{ with $ret.allOf }}
{{/*
{{/*
construct a new dict, with each of the allOf entries merged into it in
If it's a slice, just recurse.
turn.
*/}}
*/}}
{{ $all_of_values := dict }}
{{ $result_slice := slice }}
{{ range . }}
{{ with .required }}
{{ $required = union $required . }}
{{ end }}
{{/*
With merge, values from the second argument override those from the first argument.
So this order will accumulate values from allOf items, allowing later ones to override earlier
Note also that `merge` does a *deep* merge - nested maps are also
{{ range $ret }}
merged. (Slices are replaced though.)
{{ $resolved := partial "json-schema/resolve-allof" . }}
*/}}
{{ $result_slice = $result_slice | append $resolved }}
{{ $all_of_values = merge $all_of_values . }}
{{ end }}
{{ end }}
{{/*
{{ $ret = $result_slice }}
Finally, merge in the original, allowing the original to override allOf.
{{ end }}
*/}}
{{ $ret = merge $all_of_values $ret }}
{{ if reflect.IsMap $ret }}
{{/*
{{/*
Except that if allOf *itself* contains allOf (ie, the parent also
First, we recurse into the other keys. Doing it now avoids to recurse
inherits from a grandparent), then we replace allOf in the original
twice in keys resolved by allOf values.
with that in the parent. Below, we see that this has happened, and
recurse.
TODO: surely it would be better to simply do the recursion as we iterate
though the allOf list above - not least because we might have multiple
parents with different grandparents, and by doing this we only get one
set of grandparents.
*/}}
*/}}
{{ with $all_of_values.allOf }}
{{ range $key, $value := $ret }}
{{ $ret = merge $ret (dict "allOf" . ) }}
{{ if ne $key "allOf" }}
{{ $resolved := partial "json-schema/resolve-allof" $value }}
{{ $ret = merge $ret (dict $key $resolved) }}
{{ end }}
{{ end }}
{{ end }}
{{/*
{{/*
special-case 'required': replace it with the union of all the
We special-case 'required', and accumulate the values from all the 'allOf'
'required' arrays from the original and allOf values.
entries (rather than simply overriding them). Start the accumulation here.
XXX: but first we merge in the original 'required', again? why
do we do that? it should already have been done at the start.
*/}}
*/}}
{{ with $ret.required }}
{{ $required := slice }}
{{ $required = union $required $ret.required }}
{{ end }}
{{ $ret = merge $ret (dict "required" $required) }}
{{ with $ret.allOf }}
{{ end }}
{{/*
{{/*
If we replaced the 'allOf' dict with one from a grandparent, we now
construct a new dict, with each of the allOf entries merged into it in
need to recurse.
turn.
*/}}
*/}}
{{ if ne $ret.allOf $original.allOf }}
{{ $all_of_values := dict }}
{{ range . }}
{{/*
First, resolve allOf in child.
*/}}
{{ $resolved := partial "json-schema/resolve-allof" . }}
{{ with $resolved.required }}
{{ $required = union $required . }}
{{ end }}
{{/*
With merge, values from the second argument override those from the first argument.
So this order will accumulate values from allOf items, allowing later ones to override earlier
Note also that `merge` does a *deep* merge - nested maps are also
merged. (Slices are replaced though.)
*/}}
{{ $all_of_values = merge $all_of_values $resolved }}
{{ end }}
{{/*
Finally, merge in the original, allowing the original to override allOf.
*/}}
{{ $ret = merge $all_of_values $ret }}
{{ $resolved := partial "json-schema/resolve-allof" $ret }}
{{/*
{{ $ret = merge $ret $resolved }}
special-case 'required': replace it with the union of all the
'required' arrays from the original and allOf values.
*/}}
{{ with $ret.required }}
{{ $required = union $required $ret.required }}
{{ end }}
{{ $ret = merge $ret (dict "required" $required) }}
{{ end }}
{{ end }}
{{ end }}
{{ return $ret }}
{{ return $ret }}