Debian Codegraph @

pkg/cel/openapi/adaptor.go

raw
1 /*
2 Copyright 2023 The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 package openapi
18
19 import (
20 "github.com/google/cel-go/common/types/ref"
21
22 apiservercel "k8s.io/apiserver/pkg/cel"
23 "k8s.io/apiserver/pkg/cel/common"
24 "k8s.io/kube-openapi/pkg/validation/spec"
25 )
26
27 var _ common.Schema = (*Schema)(nil)
28 var _ common.SchemaOrBool = (*SchemaOrBool)(nil)
29
30 type Schema struct {
31 Schema *spec.Schema
32 }
33
34 type SchemaOrBool struct {
35 SchemaOrBool *spec.SchemaOrBool
36 }
37
38 func (sb *SchemaOrBool) Schema() common.Schema {
39 return &Schema{Schema: sb.SchemaOrBool.Schema}
40 }
41
42 func (sb *SchemaOrBool) Allows() bool {
43 return sb.SchemaOrBool.Allows
44 }
45
46 func (s *Schema) Type() string {
47 if len(s.Schema.Type) == 0 {
48 return ""
49 }
50 return s.Schema.Type[0]
51 }
52
53 func (s *Schema) Format() string {
54 return s.Schema.Format
55 }
56
57 func (s *Schema) Pattern() string {
58 return s.Schema.Pattern
59 }
60
61 func (s *Schema) Items() common.Schema {
62 if s.Schema.Items == nil || s.Schema.Items.Schema == nil {
63 return nil
64 }
65 return &Schema{Schema: s.Schema.Items.Schema}
66 }
67
68 func (s *Schema) Properties() map[string]common.Schema {
69 if s.Schema.Properties == nil {
70 return nil
71 }
72 res := make(map[string]common.Schema, len(s.Schema.Properties))
73 for n, prop := range s.Schema.Properties {
74 // map value is unaddressable, create a shallow copy
75 // this is a shallow non-recursive copy
76 s := prop
77 res[n] = &Schema{Schema: &s}
78 }
79 return res
80 }
81
82 func (s *Schema) AdditionalProperties() common.SchemaOrBool {
83 if s.Schema.AdditionalProperties == nil {
84 return nil
85 }
86 return &SchemaOrBool{SchemaOrBool: s.Schema.AdditionalProperties}
87 }
88
89 func (s *Schema) Default() any {
90 return s.Schema.Default
91 }
92
93 func (s *Schema) Minimum() *float64 {
94 return s.Schema.Minimum
95 }
96
97 func (s *Schema) IsExclusiveMinimum() bool {
98 return s.Schema.ExclusiveMinimum
99 }
100
101 func (s *Schema) Maximum() *float64 {
102 return s.Schema.Maximum
103 }
104
105 func (s *Schema) IsExclusiveMaximum() bool {
106 return s.Schema.ExclusiveMaximum
107 }
108
109 func (s *Schema) MultipleOf() *float64 {
110 return s.Schema.MultipleOf
111 }
112
113 func (s *Schema) UniqueItems() bool {
114 return s.Schema.UniqueItems
115 }
116
117 func (s *Schema) MinItems() *int64 {
118 return s.Schema.MinItems
119 }
120
121 func (s *Schema) MaxItems() *int64 {
122 return s.Schema.MaxItems
123 }
124
125 func (s *Schema) MinLength() *int64 {
126 return s.Schema.MinLength
127 }
128
129 func (s *Schema) MaxLength() *int64 {
130 return s.Schema.MaxLength
131 }
132
133 func (s *Schema) MinProperties() *int64 {
134 return s.Schema.MinProperties
135 }
136
137 func (s *Schema) MaxProperties() *int64 {
138 return s.Schema.MaxProperties
139 }
140
141 func (s *Schema) Required() []string {
142 return s.Schema.Required
143 }
144
145 func (s *Schema) Enum() []any {
146 return s.Schema.Enum
147 }
148
149 func (s *Schema) Nullable() bool {
150 return s.Schema.Nullable
151 }
152
153 func (s *Schema) AllOf() []common.Schema {
154 var res []common.Schema
155 for _, nestedSchema := range s.Schema.AllOf {
156 nestedSchema := nestedSchema
157 res = append(res, &Schema{&nestedSchema})
158 }
159 return res
160 }
161
162 func (s *Schema) AnyOf() []common.Schema {
163 var res []common.Schema
164 for _, nestedSchema := range s.Schema.AnyOf {
165 nestedSchema := nestedSchema
166 res = append(res, &Schema{&nestedSchema})
167 }
168 return res
169 }
170
171 func (s *Schema) OneOf() []common.Schema {
172 var res []common.Schema
173 for _, nestedSchema := range s.Schema.OneOf {
174 nestedSchema := nestedSchema
175 res = append(res, &Schema{&nestedSchema})
176 }
177 return res
178 }
179
180 func (s *Schema) Not() common.Schema {
181 if s.Schema.Not == nil {
182 return nil
183 }
184 return &Schema{s.Schema.Not}
185 }
186
187 func (s *Schema) IsXIntOrString() bool {
188 return isXIntOrString(s.Schema)
189 }
190
191 func (s *Schema) IsXEmbeddedResource() bool {
192 return isXEmbeddedResource(s.Schema)
193 }
194
195 func (s *Schema) IsXPreserveUnknownFields() bool {
196 return isXPreserveUnknownFields(s.Schema)
197 }
198
199 func (s *Schema) XListType() string {
200 return getXListType(s.Schema)
201 }
202
203 func (s *Schema) XMapType() string {
204 return getXMapType(s.Schema)
205 }
206
207 func (s *Schema) XListMapKeys() []string {
208 return getXListMapKeys(s.Schema)
209 }
210
211 func (s *Schema) XValidations() []common.ValidationRule {
212 return getXValidations(s.Schema)
213 }
214
215 func (s *Schema) WithTypeAndObjectMeta() common.Schema {
216 return &Schema{common.WithTypeAndObjectMeta(s.Schema)}
217 }
218
219 func UnstructuredToVal(unstructured any, schema *spec.Schema) ref.Val {
220 return common.UnstructuredToVal(unstructured, &Schema{schema})
221 }
222
223 func SchemaDeclType(s *spec.Schema, isResourceRoot bool) *apiservercel.DeclType {
224 return common.SchemaDeclType(&Schema{Schema: s}, isResourceRoot)
225 }
226
227 func MakeMapList(sts *spec.Schema, items []interface{}) (rv common.MapList) {
228 return common.MakeMapList(&Schema{Schema: sts}, items)
229 }