You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
matrix-spec/layouts/partials/json-schema/resolve-allof.html

103 lines
3.3 KiB
HTML

{{/*
Resolves the `allOf` keyword (https://swagger.io/specification/v2/#composition-and-inheritance-polymorphism),
given a JSON schema object.
`allOf` is used to support a kind of inheritance for JSON schema objects.
An object can reference a "parent" object using `allOf`, and it then inherits
its parent's properties. If the same property is present in the child, then
we use the child's version (the child overrides the parent).
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 }}
{{/*
construct a new dict, with each of the allOf entries merged into it in
turn.
*/}}
{{ $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
Note also that `merge` does a *deep* merge - nested maps are also
merged. (Slices are replaced though.)
*/}}
{{ $all_of_values = merge $all_of_values . }}
{{ end }}
{{/*
Finally, merge in the original, allowing the original to override allOf.
*/}}
{{ $ret = merge $all_of_values $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.
*/}}
{{ with $all_of_values.allOf }}
{{ $ret = merge $ret (dict "allOf" . ) }}
{{ 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.
*/}}
{{ with $ret.required }}
{{ $required = union $required $ret.required }}
{{ end }}
{{ $ret = merge $ret (dict "required" $required) }}
{{ end }}
{{/*
If we replaced the 'allOf' dict with one from a grandparent, we now
need to recurse.
*/}}
{{ if ne $ret.allOf $original.allOf }}
{{ $resolved := partial "json-schema/resolve-allof" $ret }}
{{ $ret = merge $ret $resolved }}
{{ end }}
{{ return $ret }}