@ -1,7 +1,7 @@
{{/*
Resolves the `allOf` keyword (https://spec.openapis.org/oas/v3.1.0#composition-and-inheritance-polymorphism),
given a JSON schema object.
Resolves the `allOf` keyword (https://spec.openapis.org/oas/v3.1.0#composition-and-inheritance-polymorphism)
recursively, given a JSON schema object.
`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
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 := . }}
{{ $original := . }}
{{/*
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 }}
{{ if reflect.IsSlice $ret }}
{{/*
construct a new dict, with each of the allOf entries merged into it in
turn.
If it's a slice, just recurse.
*/}}
{{ $all_of_values := dict }}
{{ 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
{{ $result_slice := slice }}
Note also that `merge` does a *deep* merge - nested maps are also
merged. (Slices are replaced though.)
*/}}
{{ $all_of_values = merge $all_of_values . }}
{{ range $ret }}
{{ $resolved := partial "json-schema/resolve-allof" . }}
{{ $result_slice = $result_slice | append $resolved }}
{{ end }}
{{/*
Finally, merge in the original, allowing the original to override allOf.
*/}}
{{ $ret = merge $all_of_values $ret }}
{{ $ret = $result_slice }}
{{ end }}
{{ if reflect.IsMap $ret }}
{{/*
Except that if allOf *itself* contains allOf (ie, the parent also
inherits from a grandparent), then we replace allOf in the original
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.
First, we recurse into the other keys. Doing it now avoids to recurse
twice in keys resolved by allOf values.
*/}}
{{ with $all_of_values.allOf }}
{{ $ret = merge $ret (dict "allOf" . ) }}
{{ range $key, $value := $ret }}
{{ if ne $key "allOf" }}
{{ $resolved := partial "json-schema/resolve-allof" $value }}
{{ $ret = merge $ret (dict $key $resolved) }}
{{ end }}
{{ end }}
{{/*
special-case 'required': replace it with the union of all the
'required' arrays from the original and allOf values.
XXX: but first we merge in the original 'required', again? why
do we do that? it should already have been done at the start.
We special-case 'required', and accumulate the values from all the 'allOf'
entries (rather than simply overriding them). Start the accumulation here.
*/}}
{{ with $ret.required }}
{{ $required = union $required $ret.required }}
{{ end }}
{{ $required := slice }}
{{ $ret = merge $ret (dict "required" $required) }}
{{ end }}
{{ with $ret.allOf }}
{{/*
If we replaced the 'allOf' dict with one from a grandparent, we now
need to recurse.
*/}}
{{ if ne $ret.allOf $original.allOf }}
{{/*
construct a new dict, with each of the allOf entries merged into it in
turn.
*/}}
{{ $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 }}
{{ return $ret }}
Kévin Commaille
1 month ago