diff --git a/go.mod b/go.mod index 0b6b68b..8e2bc5c 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/go-openapi/runtime v0.28.0 github.com/go-openapi/strfmt v0.24.0 github.com/go-openapi/swag v0.25.1 - github.com/go-openapi/validate v0.24.0 + github.com/go-openapi/validate v0.25.0 github.com/obalunenko/getenv v1.14.1 github.com/stretchr/testify v1.11.1 ) @@ -17,11 +17,11 @@ require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/go-logr/logr v1.4.1 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-openapi/analysis v0.23.0 // indirect - github.com/go-openapi/jsonpointer v0.21.0 // indirect - github.com/go-openapi/jsonreference v0.21.0 // indirect - github.com/go-openapi/loads v0.22.0 // indirect - github.com/go-openapi/spec v0.21.0 // indirect + github.com/go-openapi/analysis v0.24.0 // indirect + github.com/go-openapi/jsonpointer v0.22.1 // indirect + github.com/go-openapi/jsonreference v0.21.2 // indirect + github.com/go-openapi/loads v0.23.1 // indirect + github.com/go-openapi/spec v0.22.0 // indirect github.com/go-openapi/swag/cmdutils v0.25.1 // indirect github.com/go-openapi/swag/conv v0.25.1 // indirect github.com/go-openapi/swag/fileutils v0.25.1 // indirect diff --git a/go.sum b/go.sum index 0c547ec..98d144c 100644 --- a/go.sum +++ b/go.sum @@ -8,20 +8,20 @@ github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-openapi/analysis v0.23.0 h1:aGday7OWupfMs+LbmLZG4k0MYXIANxcuBTYUC03zFCU= -github.com/go-openapi/analysis v0.23.0/go.mod h1:9mz9ZWaSlV8TvjQHLl2mUW2PbZtemkE8yA5v22ohupo= +github.com/go-openapi/analysis v0.24.0 h1:vE/VFFkICKyYuTWYnplQ+aVr45vlG6NcZKC7BdIXhsA= +github.com/go-openapi/analysis v0.24.0/go.mod h1:GLyoJA+bvmGGaHgpfeDh8ldpGo69fAJg7eeMDMRCIrw= github.com/go-openapi/errors v0.22.3 h1:k6Hxa5Jg1TUyZnOwV2Lh81j8ayNw5VVYLvKrp4zFKFs= github.com/go-openapi/errors v0.22.3/go.mod h1:+WvbaBBULWCOna//9B9TbLNGSFOfF8lY9dw4hGiEiKQ= -github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= -github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= -github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ= -github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4= -github.com/go-openapi/loads v0.22.0 h1:ECPGd4jX1U6NApCGG1We+uEozOAvXvJSF4nnwHZ8Aco= -github.com/go-openapi/loads v0.22.0/go.mod h1:yLsaTCS92mnSAZX5WWoxszLj0u+Ojl+Zs5Stn1oF+rs= +github.com/go-openapi/jsonpointer v0.22.1 h1:sHYI1He3b9NqJ4wXLoJDKmUmHkWy/L7rtEo92JUxBNk= +github.com/go-openapi/jsonpointer v0.22.1/go.mod h1:pQT9OsLkfz1yWoMgYFy4x3U5GY5nUlsOn1qSBH5MkCM= +github.com/go-openapi/jsonreference v0.21.2 h1:Wxjda4M/BBQllegefXrY/9aq1fxBA8sI5M/lFU6tSWU= +github.com/go-openapi/jsonreference v0.21.2/go.mod h1:pp3PEjIsJ9CZDGCNOyXIQxsNuroxm8FAJ/+quA0yKzQ= +github.com/go-openapi/loads v0.23.1 h1:H8A0dX2KDHxDzc797h0+uiCZ5kwE2+VojaQVaTlXvS0= +github.com/go-openapi/loads v0.23.1/go.mod h1:hZSXkyACCWzWPQqizAv/Ye0yhi2zzHwMmoXQ6YQml44= github.com/go-openapi/runtime v0.28.0 h1:gpPPmWSNGo214l6n8hzdXYhPuJcGtziTOgUpvsFWGIQ= github.com/go-openapi/runtime v0.28.0/go.mod h1:QN7OzcS+XuYmkQLw05akXk0jRH/eZ3kb18+1KwW9gyc= -github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY= -github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk= +github.com/go-openapi/spec v0.22.0 h1:xT/EsX4frL3U09QviRIZXvkh80yibxQmtoEvyqug0Tw= +github.com/go-openapi/spec v0.22.0/go.mod h1:K0FhKxkez8YNS94XzF8YKEMULbFrRw4m15i2YUht4L0= github.com/go-openapi/strfmt v0.24.0 h1:dDsopqbI3wrrlIzeXRbqMihRNnjzGC+ez4NQaAAJLuc= github.com/go-openapi/strfmt v0.24.0/go.mod h1:Lnn1Bk9rZjXxU9VMADbEEOo7D7CDyKGLsSKekhFr7s4= github.com/go-openapi/swag v0.25.1 h1:6uwVsx+/OuvFVPqfQmOOPsqTcm5/GkBhNwLqIR916n8= @@ -50,8 +50,8 @@ github.com/go-openapi/swag/typeutils v0.25.1 h1:rD/9HsEQieewNt6/k+JBwkxuAHktFtH3 github.com/go-openapi/swag/typeutils v0.25.1/go.mod h1:9McMC/oCdS4BKwk2shEB7x17P6HmMmA6dQRtAkSnNb8= github.com/go-openapi/swag/yamlutils v0.25.1 h1:mry5ez8joJwzvMbaTGLhw8pXUnhDK91oSJLDPF1bmGk= github.com/go-openapi/swag/yamlutils v0.25.1/go.mod h1:cm9ywbzncy3y6uPm/97ysW8+wZ09qsks+9RS8fLWKqg= -github.com/go-openapi/validate v0.24.0 h1:LdfDKwNbpB6Vn40xhTdNZAnfLECL81w+VX3BumrGD58= -github.com/go-openapi/validate v0.24.0/go.mod h1:iyeX1sEufmv3nPbBdX3ieNviWnOZaJ1+zquzJEf2BAQ= +github.com/go-openapi/validate v0.25.0 h1:JD9eGX81hDTjoY3WOzh6WqxVBVl7xjsLnvDo1GL5WPU= +github.com/go-openapi/validate v0.25.0/go.mod h1:SUY7vKrN5FiwK6LyvSwKjDfLNirSfWwHNgxd2l29Mmw= github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= diff --git a/vendor/github.com/go-openapi/analysis/.golangci.yml b/vendor/github.com/go-openapi/analysis/.golangci.yml index 22f8d21..5609b4f 100644 --- a/vendor/github.com/go-openapi/analysis/.golangci.yml +++ b/vendor/github.com/go-openapi/analysis/.golangci.yml @@ -1,61 +1,75 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - noinlineerr + - nonamedreturns - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/analysis/analyzer.go b/vendor/github.com/go-openapi/analysis/analyzer.go index c17aee1..3e57de8 100644 --- a/vendor/github.com/go-openapi/analysis/analyzer.go +++ b/vendor/github.com/go-openapi/analysis/analyzer.go @@ -22,7 +22,13 @@ import ( "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/mangling" +) + +const ( + allocLargeMap = 150 + allocMediumMap = 64 + allocSmallMap = 10 ) type referenceAnalysis struct { @@ -136,23 +142,6 @@ func (p *enumAnalysis) addSchemaEnum(key string, enum []interface{}) { p.addEnum(key, enum) } -// New takes a swagger spec object and returns an analyzed spec document. -// The analyzed document contains a number of indices that make it easier to -// reason about semantics of a swagger specification for use in code generation -// or validation etc. -func New(doc *spec.Swagger) *Spec { - a := &Spec{ - spec: doc, - references: referenceAnalysis{}, - patterns: patternAnalysis{}, - enums: enumAnalysis{}, - } - a.reset() - a.initialize() - - return a -} - // Spec is an analyzed specification object. It takes a swagger spec object and turns it into a registry // with a bunch of utility methods to act on the information in the spec. type Spec struct { @@ -168,494 +157,522 @@ type Spec struct { allOfs map[string]SchemaRef } -func (s *Spec) reset() { - s.consumes = make(map[string]struct{}, 150) - s.produces = make(map[string]struct{}, 150) - s.authSchemes = make(map[string]struct{}, 150) - s.operations = make(map[string]map[string]*spec.Operation, 150) - s.allSchemas = make(map[string]SchemaRef, 150) - s.allOfs = make(map[string]SchemaRef, 150) - s.references.schemas = make(map[string]spec.Ref, 150) - s.references.pathItems = make(map[string]spec.Ref, 150) - s.references.responses = make(map[string]spec.Ref, 150) - s.references.parameters = make(map[string]spec.Ref, 150) - s.references.items = make(map[string]spec.Ref, 150) - s.references.headerItems = make(map[string]spec.Ref, 150) - s.references.parameterItems = make(map[string]spec.Ref, 150) - s.references.allRefs = make(map[string]spec.Ref, 150) - s.patterns.parameters = make(map[string]string, 150) - s.patterns.headers = make(map[string]string, 150) - s.patterns.items = make(map[string]string, 150) - s.patterns.schemas = make(map[string]string, 150) - s.patterns.allPatterns = make(map[string]string, 150) - s.enums.parameters = make(map[string][]interface{}, 150) - s.enums.headers = make(map[string][]interface{}, 150) - s.enums.items = make(map[string][]interface{}, 150) - s.enums.schemas = make(map[string][]interface{}, 150) - s.enums.allEnums = make(map[string][]interface{}, 150) +// New takes a swagger spec object and returns an analyzed spec document. +// The analyzed document contains a number of indices that make it easier to +// reason about semantics of a swagger specification for use in code generation +// or validation etc. +func New(doc *spec.Swagger) *Spec { + a := &Spec{ + spec: doc, + references: referenceAnalysis{}, + patterns: patternAnalysis{}, + enums: enumAnalysis{}, + } + a.reset() + a.initialize() + + return a } -func (s *Spec) reload() { - s.reset() - s.initialize() +// SecurityRequirement is a representation of a security requirement for an operation +type SecurityRequirement struct { + Name string + Scopes []string } -func (s *Spec) initialize() { - for _, c := range s.spec.Consumes { - s.consumes[c] = struct{}{} - } - for _, c := range s.spec.Produces { - s.produces[c] = struct{}{} - } - for _, ss := range s.spec.Security { - for k := range ss { - s.authSchemes[k] = struct{}{} - } +// SecurityRequirementsFor gets the security requirements for the operation +func (s *Spec) SecurityRequirementsFor(operation *spec.Operation) [][]SecurityRequirement { + if s.spec.Security == nil && operation.Security == nil { + return nil } - for path, pathItem := range s.AllPaths() { - s.analyzeOperations(path, &pathItem) //#nosec + + schemes := s.spec.Security + if operation.Security != nil { + schemes = operation.Security } - for name, parameter := range s.spec.Parameters { - refPref := slashpath.Join("/parameters", jsonpointer.Escape(name)) - if parameter.Items != nil { - s.analyzeItems("items", parameter.Items, refPref, "parameter") - } - if parameter.In == "body" && parameter.Schema != nil { - s.analyzeSchema("schema", parameter.Schema, refPref) - } - if parameter.Pattern != "" { - s.patterns.addParameterPattern(refPref, parameter.Pattern) - } - if len(parameter.Enum) > 0 { - s.enums.addParameterEnum(refPref, parameter.Enum) + result := [][]SecurityRequirement{} + for _, scheme := range schemes { + if len(scheme) == 0 { + // append a zero object for anonymous + result = append(result, []SecurityRequirement{{}}) + + continue } - } - for name, response := range s.spec.Responses { - refPref := slashpath.Join("/responses", jsonpointer.Escape(name)) - for k, v := range response.Headers { - hRefPref := slashpath.Join(refPref, "headers", k) - if v.Items != nil { - s.analyzeItems("items", v.Items, hRefPref, "header") - } - if v.Pattern != "" { - s.patterns.addHeaderPattern(hRefPref, v.Pattern) - } - if len(v.Enum) > 0 { - s.enums.addHeaderEnum(hRefPref, v.Enum) + var reqs []SecurityRequirement + for k, v := range scheme { + if v == nil { + v = []string{} } + reqs = append(reqs, SecurityRequirement{Name: k, Scopes: v}) } - if response.Schema != nil { - s.analyzeSchema("schema", response.Schema, refPref) - } - } - for name := range s.spec.Definitions { - schema := s.spec.Definitions[name] - s.analyzeSchema(name, &schema, "/definitions") + result = append(result, reqs) } - // TODO: after analyzing all things and flattening schemas etc - // resolve all the collected references to their final representations - // best put in a separate method because this could get expensive + + return result } -func (s *Spec) analyzeOperations(path string, pi *spec.PathItem) { - // TODO: resolve refs here? - // Currently, operations declared via pathItem $ref are known only after expansion - op := pi - if pi.Ref.String() != "" { - key := slashpath.Join("/paths", jsonpointer.Escape(path)) - s.references.addPathItemRef(key, pi) - } - s.analyzeOperation("GET", path, op.Get) - s.analyzeOperation("PUT", path, op.Put) - s.analyzeOperation("POST", path, op.Post) - s.analyzeOperation("PATCH", path, op.Patch) - s.analyzeOperation("DELETE", path, op.Delete) - s.analyzeOperation("HEAD", path, op.Head) - s.analyzeOperation("OPTIONS", path, op.Options) - for i, param := range op.Parameters { - refPref := slashpath.Join("/paths", jsonpointer.Escape(path), "parameters", strconv.Itoa(i)) - if param.Ref.String() != "" { - s.references.addParamRef(refPref, ¶m) //#nosec - } - if param.Pattern != "" { - s.patterns.addParameterPattern(refPref, param.Pattern) - } - if len(param.Enum) > 0 { - s.enums.addParameterEnum(refPref, param.Enum) - } - if param.Items != nil { - s.analyzeItems("items", param.Items, refPref, "parameter") - } - if param.Schema != nil { - s.analyzeSchema("schema", param.Schema, refPref) +// SecurityDefinitionsForRequirements gets the matching security definitions for a set of requirements +func (s *Spec) SecurityDefinitionsForRequirements(requirements []SecurityRequirement) map[string]spec.SecurityScheme { + result := make(map[string]spec.SecurityScheme) + + for _, v := range requirements { + if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { + if definition != nil { + result[v.Name] = *definition + } } } -} -func (s *Spec) analyzeItems(name string, items *spec.Items, prefix, location string) { - if items == nil { - return - } - refPref := slashpath.Join(prefix, name) - s.analyzeItems(name, items.Items, refPref, location) - if items.Ref.String() != "" { - s.references.addItemsRef(refPref, items, location) - } - if items.Pattern != "" { - s.patterns.addItemsPattern(refPref, items.Pattern) - } - if len(items.Enum) > 0 { - s.enums.addItemsEnum(refPref, items.Enum) - } + return result } -func (s *Spec) analyzeParameter(prefix string, i int, param spec.Parameter) { - refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i)) - if param.Ref.String() != "" { - s.references.addParamRef(refPref, ¶m) //#nosec +// SecurityDefinitionsFor gets the matching security definitions for a set of requirements +func (s *Spec) SecurityDefinitionsFor(operation *spec.Operation) map[string]spec.SecurityScheme { + requirements := s.SecurityRequirementsFor(operation) + if len(requirements) == 0 { + return nil } - if param.Pattern != "" { - s.patterns.addParameterPattern(refPref, param.Pattern) - } + result := make(map[string]spec.SecurityScheme) + for _, reqs := range requirements { + for _, v := range reqs { + if v.Name == "" { + // optional requirement + continue + } - if len(param.Enum) > 0 { - s.enums.addParameterEnum(refPref, param.Enum) - } + if _, ok := result[v.Name]; ok { + // duplicate requirement + continue + } - s.analyzeItems("items", param.Items, refPref, "parameter") - if param.In == "body" && param.Schema != nil { - s.analyzeSchema("schema", param.Schema, refPref) + if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { + if definition != nil { + result[v.Name] = *definition + } + } + } } + + return result } -func (s *Spec) analyzeOperation(method, path string, op *spec.Operation) { - if op == nil { - return - } +// ConsumesFor gets the mediatypes for the operation +func (s *Spec) ConsumesFor(operation *spec.Operation) []string { + if len(operation.Consumes) == 0 { + cons := make(map[string]struct{}, len(s.spec.Consumes)) + for _, k := range s.spec.Consumes { + cons[k] = struct{}{} + } - for _, c := range op.Consumes { - s.consumes[c] = struct{}{} + return s.structMapKeys(cons) } - for _, c := range op.Produces { - s.produces[c] = struct{}{} + cons := make(map[string]struct{}, len(operation.Consumes)) + for _, c := range operation.Consumes { + cons[c] = struct{}{} } - for _, ss := range op.Security { - for k := range ss { - s.authSchemes[k] = struct{}{} + return s.structMapKeys(cons) +} + +// ProducesFor gets the mediatypes for the operation +func (s *Spec) ProducesFor(operation *spec.Operation) []string { + if len(operation.Produces) == 0 { + prod := make(map[string]struct{}, len(s.spec.Produces)) + for _, k := range s.spec.Produces { + prod[k] = struct{}{} } - } - if _, ok := s.operations[method]; !ok { - s.operations[method] = make(map[string]*spec.Operation) + return s.structMapKeys(prod) } - s.operations[method][path] = op - prefix := slashpath.Join("/paths", jsonpointer.Escape(path), strings.ToLower(method)) - for i, param := range op.Parameters { - s.analyzeParameter(prefix, i, param) + prod := make(map[string]struct{}, len(operation.Produces)) + for _, c := range operation.Produces { + prod[c] = struct{}{} } - if op.Responses == nil { - return - } + return s.structMapKeys(prod) +} - if op.Responses.Default != nil { - s.analyzeDefaultResponse(prefix, op.Responses.Default) - } +func mapKeyFromParam(param *spec.Parameter) string { + return fmt.Sprintf("%s#%s", param.In, fieldNameFromParam(param)) +} - for k, res := range op.Responses.StatusCodeResponses { - s.analyzeResponse(prefix, k, res) +func fieldNameFromParam(param *spec.Parameter) string { + // TODO: this should be x-go-name + if nm, ok := param.Extensions.GetString("go-name"); ok { + return nm } + mangler := mangling.NewNameMangler() + + return mangler.ToGoName(param.Name) } -func (s *Spec) analyzeDefaultResponse(prefix string, res *spec.Response) { - refPref := slashpath.Join(prefix, "responses", "default") - if res.Ref.String() != "" { - s.references.addResponseRef(refPref, res) - } +// ErrorOnParamFunc is a callback function to be invoked +// whenever an error is encountered while resolving references +// on parameters. +// +// This function takes as input the spec.Parameter which triggered the +// error and the error itself. +// +// If the callback function returns false, the calling function should bail. +// +// If it returns true, the calling function should continue evaluating parameters. +// A nil ErrorOnParamFunc must be evaluated as equivalent to panic(). +type ErrorOnParamFunc func(spec.Parameter, error) bool - for k, v := range res.Headers { - hRefPref := slashpath.Join(refPref, "headers", k) - s.analyzeItems("items", v.Items, hRefPref, "header") - if v.Pattern != "" { - s.patterns.addHeaderPattern(hRefPref, v.Pattern) +// ParametersFor the specified operation id. +// +// Assumes parameters properly resolve references if any and that +// such references actually resolve to a parameter object. +// Otherwise, panics. +func (s *Spec) ParametersFor(operationID string) []spec.Parameter { + return s.SafeParametersFor(operationID, nil) +} + +// SafeParametersFor the specified operation id. +// +// Does not assume parameters properly resolve references or that +// such references actually resolve to a parameter object. +// +// Upon error, invoke a ErrorOnParamFunc callback with the erroneous +// parameters. If the callback is set to nil, panics upon errors. +func (s *Spec) SafeParametersFor(operationID string, callmeOnError ErrorOnParamFunc) []spec.Parameter { + gatherParams := func(pi *spec.PathItem, op *spec.Operation) []spec.Parameter { + bag := make(map[string]spec.Parameter) + s.paramsAsMap(pi.Parameters, bag, callmeOnError) + s.paramsAsMap(op.Parameters, bag, callmeOnError) + + var res []spec.Parameter + for _, v := range bag { + res = append(res, v) } + + return res } - if res.Schema != nil { - s.analyzeSchema("schema", res.Schema, refPref) + for _, pi := range s.spec.Paths.Paths { + if pi.Get != nil && pi.Get.ID == operationID { + return gatherParams(&pi, pi.Get) //#nosec + } + if pi.Head != nil && pi.Head.ID == operationID { + return gatherParams(&pi, pi.Head) //#nosec + } + if pi.Options != nil && pi.Options.ID == operationID { + return gatherParams(&pi, pi.Options) //#nosec + } + if pi.Post != nil && pi.Post.ID == operationID { + return gatherParams(&pi, pi.Post) //#nosec + } + if pi.Patch != nil && pi.Patch.ID == operationID { + return gatherParams(&pi, pi.Patch) //#nosec + } + if pi.Put != nil && pi.Put.ID == operationID { + return gatherParams(&pi, pi.Put) //#nosec + } + if pi.Delete != nil && pi.Delete.ID == operationID { + return gatherParams(&pi, pi.Delete) //#nosec + } } + + return nil } -func (s *Spec) analyzeResponse(prefix string, k int, res spec.Response) { - refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k)) - if res.Ref.String() != "" { - s.references.addResponseRef(refPref, &res) //#nosec +// ParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that +// apply for the method and path. +// +// Assumes parameters properly resolve references if any and that +// such references actually resolve to a parameter object. +// Otherwise, panics. +func (s *Spec) ParamsFor(method, path string) map[string]spec.Parameter { + return s.SafeParamsFor(method, path, nil) +} + +// SafeParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that +// apply for the method and path. +// +// Does not assume parameters properly resolve references or that +// such references actually resolve to a parameter object. +// +// Upon error, invoke a ErrorOnParamFunc callback with the erroneous +// parameters. If the callback is set to nil, panics upon errors. +func (s *Spec) SafeParamsFor(method, path string, callmeOnError ErrorOnParamFunc) map[string]spec.Parameter { + res := make(map[string]spec.Parameter) + if pi, ok := s.spec.Paths.Paths[path]; ok { + s.paramsAsMap(pi.Parameters, res, callmeOnError) + s.paramsAsMap(s.operations[strings.ToUpper(method)][path].Parameters, res, callmeOnError) } - for k, v := range res.Headers { - hRefPref := slashpath.Join(refPref, "headers", k) - s.analyzeItems("items", v.Items, hRefPref, "header") - if v.Pattern != "" { - s.patterns.addHeaderPattern(hRefPref, v.Pattern) - } + return res +} - if len(v.Enum) > 0 { - s.enums.addHeaderEnum(hRefPref, v.Enum) +// OperationForName gets the operation for the given id +func (s *Spec) OperationForName(operationID string) (string, string, *spec.Operation, bool) { + for method, pathItem := range s.operations { + for path, op := range pathItem { + if operationID == op.ID { + return method, path, op, true + } } } - if res.Schema != nil { - s.analyzeSchema("schema", res.Schema, refPref) - } + return "", "", nil, false } -func (s *Spec) analyzeSchema(name string, schema *spec.Schema, prefix string) { - refURI := slashpath.Join(prefix, jsonpointer.Escape(name)) - schRef := SchemaRef{ - Name: name, - Schema: schema, - Ref: spec.MustCreateRef("#" + refURI), - TopLevel: prefix == "/definitions", +// OperationFor the given method and path +func (s *Spec) OperationFor(method, path string) (*spec.Operation, bool) { + if mp, ok := s.operations[strings.ToUpper(method)]; ok { + op, fn := mp[path] + + return op, fn } - s.allSchemas["#"+refURI] = schRef + return nil, false +} - if schema.Ref.String() != "" { - s.references.addSchemaRef(refURI, schRef) - } +// Operations gathers all the operations specified in the spec document +func (s *Spec) Operations() map[string]map[string]*spec.Operation { + return s.operations +} - if schema.Pattern != "" { - s.patterns.addSchemaPattern(refURI, schema.Pattern) +// AllPaths returns all the paths in the swagger spec +func (s *Spec) AllPaths() map[string]spec.PathItem { + if s.spec == nil || s.spec.Paths == nil { + return nil } - if len(schema.Enum) > 0 { - s.enums.addSchemaEnum(refURI, schema.Enum) - } + return s.spec.Paths.Paths +} - for k, v := range schema.Definitions { - v := v - s.analyzeSchema(k, &v, slashpath.Join(refURI, "definitions")) +// OperationIDs gets all the operation ids based on method an dpath +func (s *Spec) OperationIDs() []string { + if len(s.operations) == 0 { + return nil } - for k, v := range schema.Properties { - v := v - s.analyzeSchema(k, &v, slashpath.Join(refURI, "properties")) + result := make([]string, 0, len(s.operations)) + for method, v := range s.operations { + for p, o := range v { + if o.ID != "" { + result = append(result, o.ID) + } else { + result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) + } + } } - for k, v := range schema.PatternProperties { - v := v - // NOTE: swagger 2.0 does not support PatternProperties. - // However it is possible to analyze this in a schema - s.analyzeSchema(k, &v, slashpath.Join(refURI, "patternProperties")) - } + return result +} - for i := range schema.AllOf { - v := &schema.AllOf[i] - s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "allOf")) +// OperationMethodPaths gets all the operation ids based on method an dpath +func (s *Spec) OperationMethodPaths() []string { + if len(s.operations) == 0 { + return nil } - if len(schema.AllOf) > 0 { - s.allOfs["#"+refURI] = schRef + result := make([]string, 0, len(s.operations)) + for method, v := range s.operations { + for p := range v { + result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) + } } - for i := range schema.AnyOf { - v := &schema.AnyOf[i] - // NOTE: swagger 2.0 does not support anyOf constructs. - // However it is possible to analyze this in a schema - s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "anyOf")) - } + return result +} - for i := range schema.OneOf { - v := &schema.OneOf[i] - // NOTE: swagger 2.0 does not support oneOf constructs. - // However it is possible to analyze this in a schema - s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "oneOf")) - } +// RequiredConsumes gets all the distinct consumes that are specified in the specification document +func (s *Spec) RequiredConsumes() []string { + return s.structMapKeys(s.consumes) +} - if schema.Not != nil { - // NOTE: swagger 2.0 does not support "not" constructs. - // However it is possible to analyze this in a schema - s.analyzeSchema("not", schema.Not, refURI) - } +// RequiredProduces gets all the distinct produces that are specified in the specification document +func (s *Spec) RequiredProduces() []string { + return s.structMapKeys(s.produces) +} - if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil { - s.analyzeSchema("additionalProperties", schema.AdditionalProperties.Schema, refURI) - } +// RequiredSecuritySchemes gets all the distinct security schemes that are specified in the swagger spec +func (s *Spec) RequiredSecuritySchemes() []string { + return s.structMapKeys(s.authSchemes) +} - if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil { - // NOTE: swagger 2.0 does not support AdditionalItems. - // However it is possible to analyze this in a schema - s.analyzeSchema("additionalItems", schema.AdditionalItems.Schema, refURI) +// SchemaRef is a reference to a schema +type SchemaRef struct { + Name string + Ref spec.Ref + Schema *spec.Schema + TopLevel bool +} + +// SchemasWithAllOf returns schema references to all schemas that are defined +// with an allOf key +func (s *Spec) SchemasWithAllOf() (result []SchemaRef) { + for _, v := range s.allOfs { + result = append(result, v) } - if schema.Items != nil { - if schema.Items.Schema != nil { - s.analyzeSchema("items", schema.Items.Schema, refURI) - } + return +} - for i := range schema.Items.Schemas { - sch := &schema.Items.Schemas[i] - s.analyzeSchema(strconv.Itoa(i), sch, slashpath.Join(refURI, "items")) - } +// AllDefinitions returns schema references for all the definitions that were discovered +func (s *Spec) AllDefinitions() (result []SchemaRef) { + for _, v := range s.allSchemas { + result = append(result, v) } -} -// SecurityRequirement is a representation of a security requirement for an operation -type SecurityRequirement struct { - Name string - Scopes []string + return } -// SecurityRequirementsFor gets the security requirements for the operation -func (s *Spec) SecurityRequirementsFor(operation *spec.Operation) [][]SecurityRequirement { - if s.spec.Security == nil && operation.Security == nil { - return nil +// AllDefinitionReferences returns json refs for all the discovered schemas +func (s *Spec) AllDefinitionReferences() (result []string) { + for _, v := range s.references.schemas { + result = append(result, v.String()) } - schemes := s.spec.Security - if operation.Security != nil { - schemes = operation.Security + return +} + +// AllParameterReferences returns json refs for all the discovered parameters +func (s *Spec) AllParameterReferences() (result []string) { + for _, v := range s.references.parameters { + result = append(result, v.String()) } - result := [][]SecurityRequirement{} - for _, scheme := range schemes { - if len(scheme) == 0 { - // append a zero object for anonymous - result = append(result, []SecurityRequirement{{}}) + return +} - continue - } +// AllResponseReferences returns json refs for all the discovered responses +func (s *Spec) AllResponseReferences() (result []string) { + for _, v := range s.references.responses { + result = append(result, v.String()) + } - var reqs []SecurityRequirement - for k, v := range scheme { - if v == nil { - v = []string{} - } - reqs = append(reqs, SecurityRequirement{Name: k, Scopes: v}) - } + return +} - result = append(result, reqs) +// AllPathItemReferences returns the references for all the items +func (s *Spec) AllPathItemReferences() (result []string) { + for _, v := range s.references.pathItems { + result = append(result, v.String()) } - return result + return } -// SecurityDefinitionsForRequirements gets the matching security definitions for a set of requirements -func (s *Spec) SecurityDefinitionsForRequirements(requirements []SecurityRequirement) map[string]spec.SecurityScheme { - result := make(map[string]spec.SecurityScheme) - - for _, v := range requirements { - if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { - if definition != nil { - result[v.Name] = *definition - } - } +// AllItemsReferences returns the references for all the items in simple schemas (parameters or headers). +// +// NOTE: since Swagger 2.0 forbids $ref in simple params, this should always yield an empty slice for a valid +// Swagger 2.0 spec. +func (s *Spec) AllItemsReferences() (result []string) { + for _, v := range s.references.items { + result = append(result, v.String()) } - return result + return } -// SecurityDefinitionsFor gets the matching security definitions for a set of requirements -func (s *Spec) SecurityDefinitionsFor(operation *spec.Operation) map[string]spec.SecurityScheme { - requirements := s.SecurityRequirementsFor(operation) - if len(requirements) == 0 { - return nil +// AllReferences returns all the references found in the document, with possible duplicates +func (s *Spec) AllReferences() (result []string) { + for _, v := range s.references.allRefs { + result = append(result, v.String()) } - result := make(map[string]spec.SecurityScheme) - for _, reqs := range requirements { - for _, v := range reqs { - if v.Name == "" { - // optional requirement - continue - } + return +} - if _, ok := result[v.Name]; ok { - // duplicate requirement - continue - } +// AllRefs returns all the unique references found in the document +func (s *Spec) AllRefs() (result []spec.Ref) { + set := make(map[string]struct{}) + for _, v := range s.references.allRefs { + a := v.String() + if a == "" { + continue + } - if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { - if definition != nil { - result[v.Name] = *definition - } - } + if _, ok := set[a]; !ok { + set[a] = struct{}{} + result = append(result, v) } } - return result + return } -// ConsumesFor gets the mediatypes for the operation -func (s *Spec) ConsumesFor(operation *spec.Operation) []string { - if len(operation.Consumes) == 0 { - cons := make(map[string]struct{}, len(s.spec.Consumes)) - for _, k := range s.spec.Consumes { - cons[k] = struct{}{} - } +// ParameterPatterns returns all the patterns found in parameters +// the map is cloned to avoid accidental changes +func (s *Spec) ParameterPatterns() map[string]string { + return cloneStringMap(s.patterns.parameters) +} - return s.structMapKeys(cons) - } +// HeaderPatterns returns all the patterns found in response headers +// the map is cloned to avoid accidental changes +func (s *Spec) HeaderPatterns() map[string]string { + return cloneStringMap(s.patterns.headers) +} - cons := make(map[string]struct{}, len(operation.Consumes)) - for _, c := range operation.Consumes { - cons[c] = struct{}{} - } +// ItemsPatterns returns all the patterns found in simple array items +// the map is cloned to avoid accidental changes +func (s *Spec) ItemsPatterns() map[string]string { + return cloneStringMap(s.patterns.items) +} - return s.structMapKeys(cons) +// SchemaPatterns returns all the patterns found in schemas +// the map is cloned to avoid accidental changes +func (s *Spec) SchemaPatterns() map[string]string { + return cloneStringMap(s.patterns.schemas) } -// ProducesFor gets the mediatypes for the operation -func (s *Spec) ProducesFor(operation *spec.Operation) []string { - if len(operation.Produces) == 0 { - prod := make(map[string]struct{}, len(s.spec.Produces)) - for _, k := range s.spec.Produces { - prod[k] = struct{}{} - } +// AllPatterns returns all the patterns found in the spec +// the map is cloned to avoid accidental changes +func (s *Spec) AllPatterns() map[string]string { + return cloneStringMap(s.patterns.allPatterns) +} - return s.structMapKeys(prod) - } +// ParameterEnums returns all the enums found in parameters +// the map is cloned to avoid accidental changes +func (s *Spec) ParameterEnums() map[string][]interface{} { + return cloneEnumMap(s.enums.parameters) +} - prod := make(map[string]struct{}, len(operation.Produces)) - for _, c := range operation.Produces { - prod[c] = struct{}{} - } +// HeaderEnums returns all the enums found in response headers +// the map is cloned to avoid accidental changes +func (s *Spec) HeaderEnums() map[string][]interface{} { + return cloneEnumMap(s.enums.headers) +} - return s.structMapKeys(prod) +// ItemsEnums returns all the enums found in simple array items +// the map is cloned to avoid accidental changes +func (s *Spec) ItemsEnums() map[string][]interface{} { + return cloneEnumMap(s.enums.items) } -func mapKeyFromParam(param *spec.Parameter) string { - return fmt.Sprintf("%s#%s", param.In, fieldNameFromParam(param)) +// SchemaEnums returns all the enums found in schemas +// the map is cloned to avoid accidental changes +func (s *Spec) SchemaEnums() map[string][]interface{} { + return cloneEnumMap(s.enums.schemas) } -func fieldNameFromParam(param *spec.Parameter) string { - // TODO: this should be x-go-name - if nm, ok := param.Extensions.GetString("go-name"); ok { - return nm +// AllEnums returns all the enums found in the spec +// the map is cloned to avoid accidental changes +func (s *Spec) AllEnums() map[string][]interface{} { + return cloneEnumMap(s.enums.allEnums) +} + +func (s *Spec) structMapKeys(mp map[string]struct{}) []string { + if len(mp) == 0 { + return nil } - return swag.ToGoName(param.Name) -} + result := make([]string, 0, len(mp)) + for k := range mp { + result = append(result, k) + } -// ErrorOnParamFunc is a callback function to be invoked -// whenever an error is encountered while resolving references -// on parameters. -// -// This function takes as input the spec.Parameter which triggered the -// error and the error itself. -// -// If the callback function returns false, the calling function should bail. -// -// If it returns true, the calling function should continue evaluating parameters. -// A nil ErrorOnParamFunc must be evaluated as equivalent to panic(). -type ErrorOnParamFunc func(spec.Parameter, error) bool + return result +} func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Parameter, callmeOnError ErrorOnParamFunc) { for _, param := range parameters { @@ -675,7 +692,7 @@ func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Para obj, _, err := pr.Ref.GetPointer().Get(s.spec) if err != nil { - if callmeOnError(param, fmt.Errorf("invalid reference: %q", pr.Ref.String())) { + if callmeOnError(param, ErrInvalidRef(pr.Ref.String())) { continue } @@ -684,7 +701,7 @@ func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Para objAsParam, ok := obj.(spec.Parameter) if !ok { - if callmeOnError(param, fmt.Errorf("resolved reference is not a parameter: %q", pr.Ref.String())) { + if callmeOnError(param, ErrInvalidParameterRef(pr.Ref.String())) { continue } @@ -696,293 +713,340 @@ func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Para } } -// ParametersFor the specified operation id. -// -// Assumes parameters properly resolve references if any and that -// such references actually resolve to a parameter object. -// Otherwise, panics. -func (s *Spec) ParametersFor(operationID string) []spec.Parameter { - return s.SafeParametersFor(operationID, nil) +func (s *Spec) reset() { + s.consumes = make(map[string]struct{}, allocLargeMap) + s.produces = make(map[string]struct{}, allocLargeMap) + s.authSchemes = make(map[string]struct{}, allocLargeMap) + s.operations = make(map[string]map[string]*spec.Operation, allocLargeMap) + s.allSchemas = make(map[string]SchemaRef, allocLargeMap) + s.allOfs = make(map[string]SchemaRef, allocLargeMap) + s.references.schemas = make(map[string]spec.Ref, allocLargeMap) + s.references.pathItems = make(map[string]spec.Ref, allocLargeMap) + s.references.responses = make(map[string]spec.Ref, allocLargeMap) + s.references.parameters = make(map[string]spec.Ref, allocLargeMap) + s.references.items = make(map[string]spec.Ref, allocLargeMap) + s.references.headerItems = make(map[string]spec.Ref, allocLargeMap) + s.references.parameterItems = make(map[string]spec.Ref, allocLargeMap) + s.references.allRefs = make(map[string]spec.Ref, allocLargeMap) + s.patterns.parameters = make(map[string]string, allocLargeMap) + s.patterns.headers = make(map[string]string, allocLargeMap) + s.patterns.items = make(map[string]string, allocLargeMap) + s.patterns.schemas = make(map[string]string, allocLargeMap) + s.patterns.allPatterns = make(map[string]string, allocLargeMap) + s.enums.parameters = make(map[string][]interface{}, allocLargeMap) + s.enums.headers = make(map[string][]interface{}, allocLargeMap) + s.enums.items = make(map[string][]interface{}, allocLargeMap) + s.enums.schemas = make(map[string][]interface{}, allocLargeMap) + s.enums.allEnums = make(map[string][]interface{}, allocLargeMap) } -// SafeParametersFor the specified operation id. -// -// Does not assume parameters properly resolve references or that -// such references actually resolve to a parameter object. -// -// Upon error, invoke a ErrorOnParamFunc callback with the erroneous -// parameters. If the callback is set to nil, panics upon errors. -func (s *Spec) SafeParametersFor(operationID string, callmeOnError ErrorOnParamFunc) []spec.Parameter { - gatherParams := func(pi *spec.PathItem, op *spec.Operation) []spec.Parameter { - bag := make(map[string]spec.Parameter) - s.paramsAsMap(pi.Parameters, bag, callmeOnError) - s.paramsAsMap(op.Parameters, bag, callmeOnError) +func (s *Spec) reload() { + s.reset() + s.initialize() +} - var res []spec.Parameter - for _, v := range bag { - res = append(res, v) +func (s *Spec) initialize() { + for _, c := range s.spec.Consumes { + s.consumes[c] = struct{}{} + } + for _, c := range s.spec.Produces { + s.produces[c] = struct{}{} + } + for _, ss := range s.spec.Security { + for k := range ss { + s.authSchemes[k] = struct{}{} } - - return res + } + for path, pathItem := range s.AllPaths() { + s.analyzeOperations(path, &pathItem) //#nosec } - for _, pi := range s.spec.Paths.Paths { - if pi.Get != nil && pi.Get.ID == operationID { - return gatherParams(&pi, pi.Get) //#nosec - } - if pi.Head != nil && pi.Head.ID == operationID { - return gatherParams(&pi, pi.Head) //#nosec + for name, parameter := range s.spec.Parameters { + refPref := slashpath.Join("/parameters", jsonpointer.Escape(name)) + if parameter.Items != nil { + s.analyzeItems("items", parameter.Items, refPref, "parameter") } - if pi.Options != nil && pi.Options.ID == operationID { - return gatherParams(&pi, pi.Options) //#nosec + if parameter.In == "body" && parameter.Schema != nil { + s.analyzeSchema("schema", parameter.Schema, refPref) } - if pi.Post != nil && pi.Post.ID == operationID { - return gatherParams(&pi, pi.Post) //#nosec + if parameter.Pattern != "" { + s.patterns.addParameterPattern(refPref, parameter.Pattern) } - if pi.Patch != nil && pi.Patch.ID == operationID { - return gatherParams(&pi, pi.Patch) //#nosec + if len(parameter.Enum) > 0 { + s.enums.addParameterEnum(refPref, parameter.Enum) } - if pi.Put != nil && pi.Put.ID == operationID { - return gatherParams(&pi, pi.Put) //#nosec + } + + for name, response := range s.spec.Responses { + refPref := slashpath.Join("/responses", jsonpointer.Escape(name)) + for k, v := range response.Headers { + hRefPref := slashpath.Join(refPref, "headers", k) + if v.Items != nil { + s.analyzeItems("items", v.Items, hRefPref, "header") + } + if v.Pattern != "" { + s.patterns.addHeaderPattern(hRefPref, v.Pattern) + } + if len(v.Enum) > 0 { + s.enums.addHeaderEnum(hRefPref, v.Enum) + } } - if pi.Delete != nil && pi.Delete.ID == operationID { - return gatherParams(&pi, pi.Delete) //#nosec + if response.Schema != nil { + s.analyzeSchema("schema", response.Schema, refPref) } } - return nil + for name := range s.spec.Definitions { + schema := s.spec.Definitions[name] + s.analyzeSchema(name, &schema, "/definitions") + } + // TODO: after analyzing all things and flattening schemas etc + // resolve all the collected references to their final representations + // best put in a separate method because this could get expensive } -// ParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that -// apply for the method and path. -// -// Assumes parameters properly resolve references if any and that -// such references actually resolve to a parameter object. -// Otherwise, panics. -func (s *Spec) ParamsFor(method, path string) map[string]spec.Parameter { - return s.SafeParamsFor(method, path, nil) +func (s *Spec) analyzeOperations(path string, pi *spec.PathItem) { + // TODO: resolve refs here? + // Currently, operations declared via pathItem $ref are known only after expansion + op := pi + if pi.Ref.String() != "" { + key := slashpath.Join("/paths", jsonpointer.Escape(path)) + s.references.addPathItemRef(key, pi) + } + s.analyzeOperation("GET", path, op.Get) + s.analyzeOperation("PUT", path, op.Put) + s.analyzeOperation("POST", path, op.Post) + s.analyzeOperation("PATCH", path, op.Patch) + s.analyzeOperation("DELETE", path, op.Delete) + s.analyzeOperation("HEAD", path, op.Head) + s.analyzeOperation("OPTIONS", path, op.Options) + for i, param := range op.Parameters { + refPref := slashpath.Join("/paths", jsonpointer.Escape(path), "parameters", strconv.Itoa(i)) + if param.Ref.String() != "" { + s.references.addParamRef(refPref, ¶m) //#nosec + } + if param.Pattern != "" { + s.patterns.addParameterPattern(refPref, param.Pattern) + } + if len(param.Enum) > 0 { + s.enums.addParameterEnum(refPref, param.Enum) + } + if param.Items != nil { + s.analyzeItems("items", param.Items, refPref, "parameter") + } + if param.Schema != nil { + s.analyzeSchema("schema", param.Schema, refPref) + } + } } -// SafeParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that -// apply for the method and path. -// -// Does not assume parameters properly resolve references or that -// such references actually resolve to a parameter object. -// -// Upon error, invoke a ErrorOnParamFunc callback with the erroneous -// parameters. If the callback is set to nil, panics upon errors. -func (s *Spec) SafeParamsFor(method, path string, callmeOnError ErrorOnParamFunc) map[string]spec.Parameter { - res := make(map[string]spec.Parameter) - if pi, ok := s.spec.Paths.Paths[path]; ok { - s.paramsAsMap(pi.Parameters, res, callmeOnError) - s.paramsAsMap(s.operations[strings.ToUpper(method)][path].Parameters, res, callmeOnError) +func (s *Spec) analyzeItems(name string, items *spec.Items, prefix, location string) { + if items == nil { + return + } + refPref := slashpath.Join(prefix, name) + s.analyzeItems(name, items.Items, refPref, location) + if items.Ref.String() != "" { + s.references.addItemsRef(refPref, items, location) + } + if items.Pattern != "" { + s.patterns.addItemsPattern(refPref, items.Pattern) + } + if len(items.Enum) > 0 { + s.enums.addItemsEnum(refPref, items.Enum) } - - return res } -// OperationForName gets the operation for the given id -func (s *Spec) OperationForName(operationID string) (string, string, *spec.Operation, bool) { - for method, pathItem := range s.operations { - for path, op := range pathItem { - if operationID == op.ID { - return method, path, op, true - } - } +func (s *Spec) analyzeParameter(prefix string, i int, param spec.Parameter) { + refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i)) + if param.Ref.String() != "" { + s.references.addParamRef(refPref, ¶m) //#nosec } - return "", "", nil, false -} - -// OperationFor the given method and path -func (s *Spec) OperationFor(method, path string) (*spec.Operation, bool) { - if mp, ok := s.operations[strings.ToUpper(method)]; ok { - op, fn := mp[path] + if param.Pattern != "" { + s.patterns.addParameterPattern(refPref, param.Pattern) + } - return op, fn + if len(param.Enum) > 0 { + s.enums.addParameterEnum(refPref, param.Enum) } - return nil, false + s.analyzeItems("items", param.Items, refPref, "parameter") + if param.In == "body" && param.Schema != nil { + s.analyzeSchema("schema", param.Schema, refPref) + } } -// Operations gathers all the operations specified in the spec document -func (s *Spec) Operations() map[string]map[string]*spec.Operation { - return s.operations -} +func (s *Spec) analyzeOperation(method, path string, op *spec.Operation) { + if op == nil { + return + } -func (s *Spec) structMapKeys(mp map[string]struct{}) []string { - if len(mp) == 0 { - return nil + for _, c := range op.Consumes { + s.consumes[c] = struct{}{} } - result := make([]string, 0, len(mp)) - for k := range mp { - result = append(result, k) + for _, c := range op.Produces { + s.produces[c] = struct{}{} } - return result -} + for _, ss := range op.Security { + for k := range ss { + s.authSchemes[k] = struct{}{} + } + } -// AllPaths returns all the paths in the swagger spec -func (s *Spec) AllPaths() map[string]spec.PathItem { - if s.spec == nil || s.spec.Paths == nil { - return nil + if _, ok := s.operations[method]; !ok { + s.operations[method] = make(map[string]*spec.Operation) } - return s.spec.Paths.Paths -} + s.operations[method][path] = op + prefix := slashpath.Join("/paths", jsonpointer.Escape(path), strings.ToLower(method)) + for i, param := range op.Parameters { + s.analyzeParameter(prefix, i, param) + } -// OperationIDs gets all the operation ids based on method an dpath -func (s *Spec) OperationIDs() []string { - if len(s.operations) == 0 { - return nil + if op.Responses == nil { + return } - result := make([]string, 0, len(s.operations)) - for method, v := range s.operations { - for p, o := range v { - if o.ID != "" { - result = append(result, o.ID) - } else { - result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) - } - } + if op.Responses.Default != nil { + s.analyzeDefaultResponse(prefix, op.Responses.Default) } - return result + for k, res := range op.Responses.StatusCodeResponses { + s.analyzeResponse(prefix, k, res) + } } -// OperationMethodPaths gets all the operation ids based on method an dpath -func (s *Spec) OperationMethodPaths() []string { - if len(s.operations) == 0 { - return nil +func (s *Spec) analyzeDefaultResponse(prefix string, res *spec.Response) { + refPref := slashpath.Join(prefix, "responses", "default") + if res.Ref.String() != "" { + s.references.addResponseRef(refPref, res) } - result := make([]string, 0, len(s.operations)) - for method, v := range s.operations { - for p := range v { - result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) + for k, v := range res.Headers { + hRefPref := slashpath.Join(refPref, "headers", k) + s.analyzeItems("items", v.Items, hRefPref, "header") + if v.Pattern != "" { + s.patterns.addHeaderPattern(hRefPref, v.Pattern) } } - return result + if res.Schema != nil { + s.analyzeSchema("schema", res.Schema, refPref) + } } -// RequiredConsumes gets all the distinct consumes that are specified in the specification document -func (s *Spec) RequiredConsumes() []string { - return s.structMapKeys(s.consumes) -} +func (s *Spec) analyzeResponse(prefix string, k int, res spec.Response) { + refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k)) + if res.Ref.String() != "" { + s.references.addResponseRef(refPref, &res) //#nosec + } -// RequiredProduces gets all the distinct produces that are specified in the specification document -func (s *Spec) RequiredProduces() []string { - return s.structMapKeys(s.produces) -} + for k, v := range res.Headers { + hRefPref := slashpath.Join(refPref, "headers", k) + s.analyzeItems("items", v.Items, hRefPref, "header") + if v.Pattern != "" { + s.patterns.addHeaderPattern(hRefPref, v.Pattern) + } -// RequiredSecuritySchemes gets all the distinct security schemes that are specified in the swagger spec -func (s *Spec) RequiredSecuritySchemes() []string { - return s.structMapKeys(s.authSchemes) -} + if len(v.Enum) > 0 { + s.enums.addHeaderEnum(hRefPref, v.Enum) + } + } -// SchemaRef is a reference to a schema -type SchemaRef struct { - Name string - Ref spec.Ref - Schema *spec.Schema - TopLevel bool + if res.Schema != nil { + s.analyzeSchema("schema", res.Schema, refPref) + } } -// SchemasWithAllOf returns schema references to all schemas that are defined -// with an allOf key -func (s *Spec) SchemasWithAllOf() (result []SchemaRef) { - for _, v := range s.allOfs { - result = append(result, v) +func (s *Spec) analyzeSchema(name string, schema *spec.Schema, prefix string) { + refURI := slashpath.Join(prefix, jsonpointer.Escape(name)) + schRef := SchemaRef{ + Name: name, + Schema: schema, + Ref: spec.MustCreateRef("#" + refURI), + TopLevel: prefix == "/definitions", } - return -} + s.allSchemas["#"+refURI] = schRef -// AllDefinitions returns schema references for all the definitions that were discovered -func (s *Spec) AllDefinitions() (result []SchemaRef) { - for _, v := range s.allSchemas { - result = append(result, v) + if schema.Ref.String() != "" { + s.references.addSchemaRef(refURI, schRef) } - return -} - -// AllDefinitionReferences returns json refs for all the discovered schemas -func (s *Spec) AllDefinitionReferences() (result []string) { - for _, v := range s.references.schemas { - result = append(result, v.String()) + if schema.Pattern != "" { + s.patterns.addSchemaPattern(refURI, schema.Pattern) } - return -} + if len(schema.Enum) > 0 { + s.enums.addSchemaEnum(refURI, schema.Enum) + } -// AllParameterReferences returns json refs for all the discovered parameters -func (s *Spec) AllParameterReferences() (result []string) { - for _, v := range s.references.parameters { - result = append(result, v.String()) + for k, v := range schema.Definitions { + s.analyzeSchema(k, &v, slashpath.Join(refURI, "definitions")) } - return -} + for k, v := range schema.Properties { + s.analyzeSchema(k, &v, slashpath.Join(refURI, "properties")) + } -// AllResponseReferences returns json refs for all the discovered responses -func (s *Spec) AllResponseReferences() (result []string) { - for _, v := range s.references.responses { - result = append(result, v.String()) + for k, v := range schema.PatternProperties { + // NOTE: swagger 2.0 does not support PatternProperties. + // However it is possible to analyze this in a schema + s.analyzeSchema(k, &v, slashpath.Join(refURI, "patternProperties")) } - return -} + for i := range schema.AllOf { + v := &schema.AllOf[i] + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "allOf")) + } -// AllPathItemReferences returns the references for all the items -func (s *Spec) AllPathItemReferences() (result []string) { - for _, v := range s.references.pathItems { - result = append(result, v.String()) + if len(schema.AllOf) > 0 { + s.allOfs["#"+refURI] = schRef } - return -} + for i := range schema.AnyOf { + v := &schema.AnyOf[i] + // NOTE: swagger 2.0 does not support anyOf constructs. + // However it is possible to analyze this in a schema + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "anyOf")) + } -// AllItemsReferences returns the references for all the items in simple schemas (parameters or headers). -// -// NOTE: since Swagger 2.0 forbids $ref in simple params, this should always yield an empty slice for a valid -// Swagger 2.0 spec. -func (s *Spec) AllItemsReferences() (result []string) { - for _, v := range s.references.items { - result = append(result, v.String()) + for i := range schema.OneOf { + v := &schema.OneOf[i] + // NOTE: swagger 2.0 does not support oneOf constructs. + // However it is possible to analyze this in a schema + s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "oneOf")) } - return -} + if schema.Not != nil { + // NOTE: swagger 2.0 does not support "not" constructs. + // However it is possible to analyze this in a schema + s.analyzeSchema("not", schema.Not, refURI) + } -// AllReferences returns all the references found in the document, with possible duplicates -func (s *Spec) AllReferences() (result []string) { - for _, v := range s.references.allRefs { - result = append(result, v.String()) + if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil { + s.analyzeSchema("additionalProperties", schema.AdditionalProperties.Schema, refURI) } - return -} + if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil { + // NOTE: swagger 2.0 does not support AdditionalItems. + // However it is possible to analyze this in a schema + s.analyzeSchema("additionalItems", schema.AdditionalItems.Schema, refURI) + } -// AllRefs returns all the unique references found in the document -func (s *Spec) AllRefs() (result []spec.Ref) { - set := make(map[string]struct{}) - for _, v := range s.references.allRefs { - a := v.String() - if a == "" { - continue + if schema.Items != nil { + if schema.Items.Schema != nil { + s.analyzeSchema("items", schema.Items.Schema, refURI) } - if _, ok := set[a]; !ok { - set[a] = struct{}{} - result = append(result, v) + for i := range schema.Items.Schemas { + sch := &schema.Items.Schemas[i] + s.analyzeSchema(strconv.Itoa(i), sch, slashpath.Join(refURI, "items")) } } - - return } func cloneStringMap(source map[string]string) map[string]string { @@ -1002,63 +1066,3 @@ func cloneEnumMap(source map[string][]interface{}) map[string][]interface{} { return res } - -// ParameterPatterns returns all the patterns found in parameters -// the map is cloned to avoid accidental changes -func (s *Spec) ParameterPatterns() map[string]string { - return cloneStringMap(s.patterns.parameters) -} - -// HeaderPatterns returns all the patterns found in response headers -// the map is cloned to avoid accidental changes -func (s *Spec) HeaderPatterns() map[string]string { - return cloneStringMap(s.patterns.headers) -} - -// ItemsPatterns returns all the patterns found in simple array items -// the map is cloned to avoid accidental changes -func (s *Spec) ItemsPatterns() map[string]string { - return cloneStringMap(s.patterns.items) -} - -// SchemaPatterns returns all the patterns found in schemas -// the map is cloned to avoid accidental changes -func (s *Spec) SchemaPatterns() map[string]string { - return cloneStringMap(s.patterns.schemas) -} - -// AllPatterns returns all the patterns found in the spec -// the map is cloned to avoid accidental changes -func (s *Spec) AllPatterns() map[string]string { - return cloneStringMap(s.patterns.allPatterns) -} - -// ParameterEnums returns all the enums found in parameters -// the map is cloned to avoid accidental changes -func (s *Spec) ParameterEnums() map[string][]interface{} { - return cloneEnumMap(s.enums.parameters) -} - -// HeaderEnums returns all the enums found in response headers -// the map is cloned to avoid accidental changes -func (s *Spec) HeaderEnums() map[string][]interface{} { - return cloneEnumMap(s.enums.headers) -} - -// ItemsEnums returns all the enums found in simple array items -// the map is cloned to avoid accidental changes -func (s *Spec) ItemsEnums() map[string][]interface{} { - return cloneEnumMap(s.enums.items) -} - -// SchemaEnums returns all the enums found in schemas -// the map is cloned to avoid accidental changes -func (s *Spec) SchemaEnums() map[string][]interface{} { - return cloneEnumMap(s.enums.schemas) -} - -// AllEnums returns all the enums found in the spec -// the map is cloned to avoid accidental changes -func (s *Spec) AllEnums() map[string][]interface{} { - return cloneEnumMap(s.enums.allEnums) -} diff --git a/vendor/github.com/go-openapi/analysis/errors.go b/vendor/github.com/go-openapi/analysis/errors.go new file mode 100644 index 0000000..98133e7 --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/errors.go @@ -0,0 +1,53 @@ +package analysis + +import ( + "errors" + "fmt" +) + +type analysisError string + +const ( + ErrAnalysis analysisError = "analysis error" + ErrNoSchema analysisError = "no schema to analyze" +) + +func (e analysisError) Error() string { + return string(e) +} + +func ErrAtKey(key string, err error) error { + return errors.Join( + fmt.Errorf("key %s: %w", key, err), + ErrAnalysis, + ) +} + +func ErrInvalidRef(key string) error { + return fmt.Errorf("invalid reference: %q: %w", key, ErrAnalysis) +} + +func ErrInvalidParameterRef(key string) error { + return fmt.Errorf("resolved reference is not a parameter: %q: %w", key, ErrAnalysis) +} + +func ErrResolveSchema(err error) error { + return errors.Join( + fmt.Errorf("could not resolve schema: %w", err), + ErrAnalysis, + ) +} + +func ErrRewriteRef(key string, target any, err error) error { + return errors.Join( + fmt.Errorf("failed to rewrite ref for key %q at %v: %w", key, target, err), + ErrAnalysis, + ) +} + +func ErrInlineDefinition(key string, err error) error { + return errors.Join( + fmt.Errorf("error while creating definition %q from inline schema: %w", key, err), + ErrAnalysis, + ) +} diff --git a/vendor/github.com/go-openapi/analysis/fixer.go b/vendor/github.com/go-openapi/analysis/fixer.go index 7c2ca08..8bac3a4 100644 --- a/vendor/github.com/go-openapi/analysis/fixer.go +++ b/vendor/github.com/go-openapi/analysis/fixer.go @@ -72,7 +72,7 @@ func FixEmptyDescs(rs *spec.Responses) { // Response object if it doesn't already have one and isn't a // ref. No-op on nil input. func FixEmptyDesc(rs *spec.Response) { - if rs == nil || rs.Description != "" || rs.Ref.Ref.GetURL() != nil { + if rs == nil || rs.Description != "" || rs.Ref.GetURL() != nil { return } rs.Description = "(empty)" diff --git a/vendor/github.com/go-openapi/analysis/flatten.go b/vendor/github.com/go-openapi/analysis/flatten.go index ebedcc9..7042bb5 100644 --- a/vendor/github.com/go-openapi/analysis/flatten.go +++ b/vendor/github.com/go-openapi/analysis/flatten.go @@ -15,7 +15,6 @@ package analysis import ( - "fmt" "log" "path" "sort" @@ -52,9 +51,9 @@ type context struct { func newContext() *context { return &context{ - newRefs: make(map[string]*newRef, 150), + newRefs: make(map[string]*newRef, allocMediumMap), warnings: make([]string, 0), - resolved: make(map[string]string, 50), + resolved: make(map[string]string, allocMediumMap), } } @@ -251,7 +250,7 @@ func nameInlinedSchemas(opts *FlattenOpts) error { asch, err := Schema(SchemaOpts{Schema: sch.Schema, Root: opts.Swagger(), BasePath: opts.BasePath}) if err != nil { - return fmt.Errorf("schema analysis [%s]: %w", key, err) + return ErrAtKey(key, err) } if asch.isAnalyzedAsComplex() { // move complex schemas to definitions @@ -320,7 +319,7 @@ func importNewRef(entry sortref.RefRevIdx, refStr string, opts *FlattenOpts) err sch, err := spec.ResolveRefWithBase(opts.Swagger(), &entry.Ref, opts.ExpandOpts(false)) if err != nil { - return fmt.Errorf("could not resolve schema: %w", err) + return ErrResolveSchema(err) } // at this stage only $ref analysis matters @@ -335,7 +334,7 @@ func importNewRef(entry sortref.RefRevIdx, refStr string, opts *FlattenOpts) err // now rewrite those refs with rebase for key, ref := range partialAnalyzer.references.allRefs { if err := replace.UpdateRef(sch, key, spec.MustCreateRef(normalize.RebaseRef(entry.Ref.String(), ref.String()))); err != nil { - return fmt.Errorf("failed to rewrite ref for key %q at %s: %w", key, entry.Ref.String(), err) + return ErrRewriteRef(key, entry.Ref.String(), err) } } @@ -429,7 +428,7 @@ func importExternalReferences(opts *FlattenOpts) (bool, error) { ref := spec.MustCreateRef(r.path) sch, err := spec.ResolveRefWithBase(opts.Swagger(), &ref, opts.ExpandOpts(false)) if err != nil { - return false, fmt.Errorf("could not resolve schema: %w", err) + return false, ErrResolveSchema(err) } r.schema = sch @@ -643,7 +642,7 @@ func stripOAIGenForRef(opts *FlattenOpts, k string, r *newRef) (bool, error) { } debugLog("re-inlined schema: parent: %s, %t", pr[0], asch.isAnalyzedAsComplex()) - replacedWithComplex = replacedWithComplex || !(path.Dir(pr[0]) == definitionsPath) && asch.isAnalyzedAsComplex() + replacedWithComplex = replacedWithComplex || path.Dir(pr[0]) != definitionsPath && asch.isAnalyzedAsComplex() } return replacedWithComplex, nil @@ -666,7 +665,7 @@ func namePointers(opts *FlattenOpts) error { result, err := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), ref) if err != nil { - return fmt.Errorf("at %s, %w", k, err) + return ErrAtKey(k, err) } replacingRef := result.Ref @@ -697,7 +696,7 @@ func namePointers(opts *FlattenOpts) error { // update current replacement, which may have been updated by previous changes of deeper elements result, erd := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), v.Ref) if erd != nil { - return fmt.Errorf("at %s, %w", key, erd) + return ErrAtKey(key, erd) } if opts.flattenContext != nil { @@ -743,9 +742,9 @@ func flattenAnonPointer(key string, v SchemaRef, refsToReplace map[string]Schema // qualify the expanded schema asch, ers := Schema(SchemaOpts{Schema: v.Schema, Root: opts.Swagger(), BasePath: opts.BasePath}) if ers != nil { - return fmt.Errorf("schema analysis [%s]: %w", key, ers) + return ErrAtKey(key, ers) } - callers := make([]string, 0, 64) + callers := make([]string, 0, allocMediumMap) debugLog("looking for callers") @@ -753,7 +752,7 @@ func flattenAnonPointer(key string, v SchemaRef, refsToReplace map[string]Schema for k, w := range an.references.allRefs { r, err := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), w) if err != nil { - return fmt.Errorf("at %s, %w", key, err) + return ErrAtKey(key, err) } if opts.flattenContext != nil { diff --git a/vendor/github.com/go-openapi/analysis/flatten_name.go b/vendor/github.com/go-openapi/analysis/flatten_name.go index c7d7938..44ffe42 100644 --- a/vendor/github.com/go-openapi/analysis/flatten_name.go +++ b/vendor/github.com/go-openapi/analysis/flatten_name.go @@ -11,7 +11,7 @@ import ( "github.com/go-openapi/analysis/internal/flatten/schutils" "github.com/go-openapi/analysis/internal/flatten/sortref" "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/mangling" ) // InlineSchemaNamer finds a new name for an inlined type @@ -43,7 +43,7 @@ func (isn *InlineSchemaNamer) Name(key string, schema *spec.Schema, aschema *Ana debugLog("rewriting schema to ref: key=%s with new name: %s", key, newName) if err := replace.RewriteSchemaToRef(isn.Spec, key, spec.MustCreateRef(path.Join(definitionsPath, newName))); err != nil { - return fmt.Errorf("error while creating definition %q from inline schema: %w", newName, err) + return ErrInlineDefinition(newName, err) } // rewrite any dependent $ref pointing to this place, @@ -54,7 +54,7 @@ func (isn *InlineSchemaNamer) Name(key string, schema *spec.Schema, aschema *Ana for k, v := range an.references.allRefs { r, erd := replace.DeepestRef(isn.opts.Swagger(), isn.opts.ExpandOpts(false), v) if erd != nil { - return fmt.Errorf("at %s, %w", k, erd) + return ErrAtKey(k, erd) } if isn.opts.flattenContext != nil { @@ -227,10 +227,15 @@ func namesForOperation(parts sortref.SplitKey, operations map[string]operations. return baseNames, startIndex } +const ( + minStartIndex = 2 + minSegments = 2 +) + func namesForDefinition(parts sortref.SplitKey) ([][]string, int) { nm := parts.DefinitionName() if nm != "" { - return [][]string{{parts.DefinitionName()}}, 2 + return [][]string{{parts.DefinitionName()}}, minStartIndex } return [][]string{}, 0 @@ -239,7 +244,7 @@ func namesForDefinition(parts sortref.SplitKey) ([][]string, int) { // partAdder knows how to interpret a schema when it comes to build a name from parts func partAdder(aschema *AnalyzedSchema) sortref.PartAdder { return func(part string) []string { - segments := make([]string, 0, 2) + segments := make([]string, 0, minSegments) if part == "items" || part == "additionalItems" { if aschema.IsTuple || aschema.IsTupleWithExtra { @@ -265,8 +270,9 @@ func mangler(o *FlattenOpts) func(string) string { if o.KeepNames { return func(in string) string { return in } } + mangler := mangling.NewNameMangler() - return swag.ToJSONName + return mangler.ToJSONName } func nameFromRef(ref spec.Ref, o *FlattenOpts) string { diff --git a/vendor/github.com/go-openapi/analysis/internal/flatten/operations/operations.go b/vendor/github.com/go-openapi/analysis/internal/flatten/operations/operations.go index 7f3a2b8..a1911b0 100644 --- a/vendor/github.com/go-openapi/analysis/internal/flatten/operations/operations.go +++ b/vendor/github.com/go-openapi/analysis/internal/flatten/operations/operations.go @@ -2,12 +2,13 @@ package operations import ( "path" + "slices" "sort" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/mangling" ) // AllOpRefsByRef returns an index of sortable operations @@ -50,12 +51,13 @@ type Provider interface { // GatherOperations builds a map of sorted operations from a spec func GatherOperations(specDoc Provider, operationIDs []string) map[string]OpRef { var oprefs OpRefs + mangler := mangling.NewNameMangler() for method, pathItem := range specDoc.Operations() { for pth, operation := range pathItem { vv := *operation oprefs = append(oprefs, OpRef{ - Key: swag.ToGoName(strings.ToLower(method) + " " + pth), + Key: mangler.ToGoName(strings.ToLower(method) + " " + pth), Method: method, Path: pth, ID: vv.ID, @@ -79,7 +81,7 @@ func GatherOperations(specDoc Provider, operationIDs []string) map[string]OpRef nm = opr.Key } - if len(operationIDs) == 0 || swag.ContainsStrings(operationIDs, opr.ID) || swag.ContainsStrings(operationIDs, nm) { + if len(operationIDs) == 0 || slices.Contains(operationIDs, opr.ID) || slices.Contains(operationIDs, nm) { opr.ID = nm opr.Op.ID = nm operations[nm] = opr diff --git a/vendor/github.com/go-openapi/analysis/internal/flatten/replace/errors.go b/vendor/github.com/go-openapi/analysis/internal/flatten/replace/errors.go new file mode 100644 index 0000000..60c3aa0 --- /dev/null +++ b/vendor/github.com/go-openapi/analysis/internal/flatten/replace/errors.go @@ -0,0 +1,61 @@ +package replace + +import ( + "errors" + "fmt" +) + +type replaceError string + +const ( + ErrReplace replaceError = "flatten replace error" + ErrUnexpectedType replaceError = "unexpected type used in getPointerFromKey" +) + +func (e replaceError) Error() string { + return string(e) +} + +func ErrNoSchemaWithRef(key string, value any) error { + return fmt.Errorf("no schema with ref found at %s for %T: %w", key, value, ErrReplace) +} + +func ErrNoSchema(key string) error { + return fmt.Errorf("no schema found at %s: %w", key, ErrReplace) +} + +func ErrNotANumber(key string, err error) error { + return errors.Join( + ErrReplace, + fmt.Errorf("%s not a number: %w", key, err), + ) +} + +func ErrUnhandledParentRewrite(key string, value any) error { + return fmt.Errorf("unhandled parent schema rewrite %s: %T: %w", key, value, ErrReplace) +} + +func ErrUnhandledParentType(key string, value any) error { + return fmt.Errorf("unhandled type for parent of %s: %T: %w", key, value, ErrReplace) +} + +func ErrNoParent(key string, err error) error { + return errors.Join( + fmt.Errorf("can't get parent for %s: %w", key, err), + ErrReplace, + ) +} + +func ErrUnhandledContainerType(key string, value any) error { + return fmt.Errorf("unhandled container type at %s: %T: %w", key, value, ErrReplace) +} + +func ErrCyclicChain(key string) error { + return fmt.Errorf("cannot resolve cyclic chain of pointers under %s: %w", key, ErrReplace) +} + +func ErrInvalidPointerType(key string, value any, err error) error { + return fmt.Errorf("invalid type for resolved JSON pointer %s. Expected a schema a, got: %T (%v): %w", + key, value, err, ErrReplace, + ) +} diff --git a/vendor/github.com/go-openapi/analysis/internal/flatten/replace/replace.go b/vendor/github.com/go-openapi/analysis/internal/flatten/replace/replace.go index c0f43e7..f30a22a 100644 --- a/vendor/github.com/go-openapi/analysis/internal/flatten/replace/replace.go +++ b/vendor/github.com/go-openapi/analysis/internal/flatten/replace/replace.go @@ -2,6 +2,7 @@ package replace import ( "encoding/json" + "errors" "fmt" "net/url" "os" @@ -13,7 +14,10 @@ import ( "github.com/go-openapi/spec" ) -const definitionsPath = "#/definitions" +const ( + definitionsPath = "#/definitions" + allocMediumMap = 64 +) var debugLog = debug.GetLogger("analysis/flatten/replace", os.Getenv("SWAGGER_DEBUG") != "") @@ -44,7 +48,7 @@ func RewriteSchemaToRef(sp *spec.Swagger, key string, ref spec.Ref) error { case map[string]interface{}: // this happens e.g. if a schema points to an extension unmarshaled as map[string]interface{} return rewriteParentRef(sp, key, ref) default: - return fmt.Errorf("no schema with ref found at %s for %T", key, value) + return ErrNoSchemaWithRef(key, value) } return nil @@ -69,7 +73,7 @@ func rewriteParentRef(sp *spec.Swagger, key string, ref spec.Ref) error { case *spec.Responses: statusCode, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", key[1:], err) + return ErrNotANumber(key[1:], err) } resp := container.StatusCodeResponses[statusCode] resp.Schema = &spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -93,7 +97,7 @@ func rewriteParentRef(sp *spec.Swagger, key string, ref spec.Ref) error { case []spec.Parameter: idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", key[1:], err) + return ErrNotANumber(key[1:], err) } param := container[idx] param.Schema = &spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -108,7 +112,7 @@ func rewriteParentRef(sp *spec.Swagger, key string, ref spec.Ref) error { case []spec.Schema: idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", key[1:], err) + return ErrNotANumber(key[1:], err) } container[idx] = spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -116,7 +120,7 @@ func rewriteParentRef(sp *spec.Swagger, key string, ref spec.Ref) error { // NOTE: this is necessarily an array - otherwise, the parent would be *Schema idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", key[1:], err) + return ErrNotANumber(key[1:], err) } container.Schemas[idx] = spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -129,7 +133,7 @@ func rewriteParentRef(sp *spec.Swagger, key string, ref spec.Ref) error { // NOTE: can't have case *spec.SchemaOrBool = parent in this case is *Schema default: - return fmt.Errorf("unhandled parent schema rewrite %s (%T)", key, pvalue) + return ErrUnhandledParentRewrite(key, pvalue) } return nil @@ -141,7 +145,7 @@ func getPointerFromKey(sp interface{}, key string) (string, interface{}, error) case *spec.Schema: case *spec.Swagger: default: - panic("unexpected type used in getPointerFromKey") + panic(ErrUnexpectedType) } if key == "#/" { return "", sp, nil @@ -150,14 +154,14 @@ func getPointerFromKey(sp interface{}, key string) (string, interface{}, error) pth, _ := url.PathUnescape(key[1:]) ptr, err := jsonpointer.New(pth) if err != nil { - return "", nil, err + return "", nil, errors.Join(err, ErrReplace) } value, _, err := ptr.Get(sp) if err != nil { debugLog("error when getting key: %s with path: %s", key, pth) - return "", nil, err + return "", nil, errors.Join(err, ErrReplace) } return pth, value, nil @@ -169,7 +173,7 @@ func getParentFromKey(sp interface{}, key string) (string, string, interface{}, case *spec.Schema: case *spec.Swagger: default: - panic("unexpected type used in getPointerFromKey") + panic(ErrUnexpectedType) } // unescape chars in key, e.g. "{}" from path params pth, _ := url.PathUnescape(key[1:]) @@ -179,11 +183,11 @@ func getParentFromKey(sp interface{}, key string) (string, string, interface{}, pptr, err := jsonpointer.New(parent) if err != nil { - return "", "", nil, err + return "", "", nil, errors.Join(err, ErrReplace) } pvalue, _, err := pptr.Get(sp) if err != nil { - return "", "", nil, fmt.Errorf("can't get parent for %s: %w", parent, err) + return "", "", nil, ErrNoParent(parent, err) } return parent, entry, pvalue, nil @@ -195,7 +199,7 @@ func UpdateRef(sp interface{}, key string, ref spec.Ref) error { case *spec.Schema: case *spec.Swagger: default: - panic("unexpected type used in getPointerFromKey") + panic(ErrUnexpectedType) } debugLog("updating ref for %s with %s", key, ref.String()) pth, value, err := getPointerFromKey(sp, key) @@ -218,7 +222,7 @@ func UpdateRef(sp interface{}, key string, ref spec.Ref) error { debugLog("rewriting holder for %T", refable) _, entry, pvalue, erp := getParentFromKey(sp, key) if erp != nil { - return err + return erp } switch container := pvalue.(type) { case spec.Definitions: @@ -230,7 +234,7 @@ func UpdateRef(sp interface{}, key string, ref spec.Ref) error { case []spec.Schema: idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", pth, err) + return ErrNotANumber(pth, err) } container[idx] = spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -238,7 +242,7 @@ func UpdateRef(sp interface{}, key string, ref spec.Ref) error { // NOTE: this is necessarily an array - otherwise, the parent would be *Schema idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", pth, err) + return ErrNotANumber(pth, err) } container.Schemas[idx] = spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} @@ -248,11 +252,11 @@ func UpdateRef(sp interface{}, key string, ref spec.Ref) error { // NOTE: can't have case *spec.SchemaOrBool = parent in this case is *Schema default: - return fmt.Errorf("unhandled container type at %s: %T", key, value) + return ErrUnhandledContainerType(key, value) } default: - return fmt.Errorf("no schema with ref found at %s for %T", key, value) + return ErrNoSchemaWithRef(key, value) } return nil @@ -272,8 +276,9 @@ func UpdateRefWithSchema(sp *spec.Swagger, key string, sch *spec.Schema) error { case spec.Schema: _, entry, pvalue, erp := getParentFromKey(sp, key) if erp != nil { - return err + return erp } + switch container := pvalue.(type) { case spec.Definitions: container[entry] = *sch @@ -284,7 +289,7 @@ func UpdateRefWithSchema(sp *spec.Swagger, key string, sch *spec.Schema) error { case []spec.Schema: idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", pth, err) + return ErrNotANumber(pth, err) } container[idx] = *sch @@ -292,7 +297,7 @@ func UpdateRefWithSchema(sp *spec.Swagger, key string, sch *spec.Schema) error { // NOTE: this is necessarily an array - otherwise, the parent would be *Schema idx, err := strconv.Atoi(entry) if err != nil { - return fmt.Errorf("%s not a number: %w", pth, err) + return ErrNotANumber(pth, err) } container.Schemas[idx] = *sch @@ -302,7 +307,7 @@ func UpdateRefWithSchema(sp *spec.Swagger, key string, sch *spec.Schema) error { // NOTE: can't have case *spec.SchemaOrBool = parent in this case is *Schema default: - return fmt.Errorf("unhandled type for parent of [%s]: %T", key, value) + return ErrUnhandledParentType(key, value) } case *spec.SchemaOrArray: *refable.Schema = *sch @@ -310,7 +315,7 @@ func UpdateRefWithSchema(sp *spec.Swagger, key string, sch *spec.Schema) error { case *spec.SchemaOrBool: *refable.Schema = *sch default: - return fmt.Errorf("no schema with ref found at %s for %T", key, value) + return ErrNoSchemaWithRef(key, value) } return nil @@ -336,8 +341,8 @@ func DeepestRef(sp *spec.Swagger, opts *spec.ExpandOptions, ref spec.Ref) (*Deep } currentRef := ref - visited := make(map[string]bool, 64) - warnings := make([]string, 0, 2) + visited := make(map[string]bool, allocMediumMap) + warnings := make([]string, 0) DOWNREF: for currentRef.String() != "" { @@ -347,8 +352,7 @@ DOWNREF: } if _, beenThere := visited[currentRef.String()]; beenThere { - return nil, - fmt.Errorf("cannot resolve cyclic chain of pointers under %s", currentRef.String()) + return nil, ErrCyclicChain(currentRef.String()) } visited[currentRef.String()] = true @@ -390,10 +394,7 @@ DOWNREF: err := asSchema.UnmarshalJSON(asJSON) if err != nil { - return nil, - fmt.Errorf("invalid type for resolved JSON pointer %s. Expected a schema a, got: %T (%v)", - currentRef.String(), value, err, - ) + return nil, ErrInvalidPointerType(currentRef.String(), value, err) } warnings = append(warnings, fmt.Sprintf("found $ref %q (response) interpreted as schema", currentRef.String())) @@ -408,10 +409,7 @@ DOWNREF: asJSON, _ := refable.MarshalJSON() var asSchema spec.Schema if err := asSchema.UnmarshalJSON(asJSON); err != nil { - return nil, - fmt.Errorf("invalid type for resolved JSON pointer %s. Expected a schema a, got: %T (%v)", - currentRef.String(), value, err, - ) + return nil, ErrInvalidPointerType(currentRef.String(), value, err) } warnings = append(warnings, fmt.Sprintf("found $ref %q (parameter) interpreted as schema", currentRef.String())) @@ -430,10 +428,7 @@ DOWNREF: asJSON, _ := json.Marshal(refable) var asSchema spec.Schema if err := asSchema.UnmarshalJSON(asJSON); err != nil { - return nil, - fmt.Errorf("unhandled type to resolve JSON pointer %s. Expected a Schema, got: %T (%v)", - currentRef.String(), value, err, - ) + return nil, ErrInvalidPointerType(currentRef.String(), value, err) } warnings = append(warnings, fmt.Sprintf("found $ref %q (%T) interpreted as schema", currentRef.String(), refable)) @@ -451,7 +446,7 @@ DOWNREF: } if sch == nil { - return nil, fmt.Errorf("no schema found at %s", currentRef.String()) + return nil, ErrNoSchema(currentRef.String()) } return &DeepestRefResult{Ref: currentRef, Schema: sch, Warnings: warnings}, nil diff --git a/vendor/github.com/go-openapi/analysis/internal/flatten/schutils/flatten_schema.go b/vendor/github.com/go-openapi/analysis/internal/flatten/schutils/flatten_schema.go index 4590236..fa7f6bf 100644 --- a/vendor/github.com/go-openapi/analysis/internal/flatten/schutils/flatten_schema.go +++ b/vendor/github.com/go-openapi/analysis/internal/flatten/schutils/flatten_schema.go @@ -4,9 +4,11 @@ package schutils import ( "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) +const allocLargeMap = 150 + // Save registers a schema as an entry in spec #/definitions func Save(sp *spec.Swagger, name string, schema *spec.Schema) { if schema == nil { @@ -14,7 +16,7 @@ func Save(sp *spec.Swagger, name string, schema *spec.Schema) { } if sp.Definitions == nil { - sp.Definitions = make(map[string]spec.Schema, 150) + sp.Definitions = make(map[string]spec.Schema, allocLargeMap) } sp.Definitions[name] = *schema @@ -23,7 +25,7 @@ func Save(sp *spec.Swagger, name string, schema *spec.Schema) { // Clone deep-clones a schema func Clone(schema *spec.Schema) *spec.Schema { var sch spec.Schema - _ = swag.FromDynamicJSON(schema, &sch) + _ = jsonutils.FromDynamicJSON(schema, &sch) return &sch } diff --git a/vendor/github.com/go-openapi/analysis/internal/flatten/sortref/keys.go b/vendor/github.com/go-openapi/analysis/internal/flatten/sortref/keys.go index ac80fc2..cbe16f6 100644 --- a/vendor/github.com/go-openapi/analysis/internal/flatten/sortref/keys.go +++ b/vendor/github.com/go-openapi/analysis/internal/flatten/sortref/keys.go @@ -86,22 +86,6 @@ func (s SplitKey) DefinitionName() string { return s[1] } -func (s SplitKey) isKeyName(i int) bool { - if i <= 0 { - return false - } - - count := 0 - for idx := i - 1; idx > 0; idx-- { - if s[idx] != "properties" { - break - } - count++ - } - - return count%2 != 0 -} - // PartAdder know how to construct the components of a new name type PartAdder func(string) []string @@ -179,7 +163,8 @@ func (s SplitKey) ResponseName() string { // PathItemRef constructs a $ref object from a split key of the form /{path}/{method} func (s SplitKey) PathItemRef() spec.Ref { - if len(s) < 3 { + const minValidPathItems = 3 + if len(s) < minValidPathItems { return spec.Ref{} } @@ -199,3 +184,19 @@ func (s SplitKey) PathRef() spec.Ref { return spec.MustCreateRef("#" + path.Join("/", paths, jsonpointer.Escape(s[1]))) } + +func (s SplitKey) isKeyName(i int) bool { + if i <= 0 { + return false + } + + count := 0 + for idx := i - 1; idx > 0; idx-- { + if s[idx] != "properties" { + break + } + count++ + } + + return count%2 != 0 +} diff --git a/vendor/github.com/go-openapi/analysis/mixin.go b/vendor/github.com/go-openapi/analysis/mixin.go index 7785a29..b0b41db 100644 --- a/vendor/github.com/go-openapi/analysis/mixin.go +++ b/vendor/github.com/go-openapi/analysis/mixin.go @@ -391,7 +391,7 @@ func mergeInfo(primary *spec.Info, m *spec.Info) []string { } if primary.Title == "" { - primary.Description = m.Description + primary.Title = m.Title } if primary.TermsOfService == "" { @@ -474,23 +474,23 @@ func initPrimary(primary *spec.Swagger) { } if primary.Security == nil { - primary.Security = make([]map[string][]string, 0, 10) + primary.Security = make([]map[string][]string, 0, allocSmallMap) } if primary.Produces == nil { - primary.Produces = make([]string, 0, 10) + primary.Produces = make([]string, 0, allocSmallMap) } if primary.Consumes == nil { - primary.Consumes = make([]string, 0, 10) + primary.Consumes = make([]string, 0, allocSmallMap) } if primary.Tags == nil { - primary.Tags = make([]spec.Tag, 0, 10) + primary.Tags = make([]spec.Tag, 0, allocSmallMap) } if primary.Schemes == nil { - primary.Schemes = make([]string, 0, 10) + primary.Schemes = make([]string, 0, allocSmallMap) } if primary.Paths == nil { diff --git a/vendor/github.com/go-openapi/analysis/schema.go b/vendor/github.com/go-openapi/analysis/schema.go index ab190db..baeb784 100644 --- a/vendor/github.com/go-openapi/analysis/schema.go +++ b/vendor/github.com/go-openapi/analysis/schema.go @@ -1,8 +1,6 @@ package analysis import ( - "errors" - "github.com/go-openapi/spec" "github.com/go-openapi/strfmt" ) @@ -19,7 +17,7 @@ type SchemaOpts struct { // patterns. func Schema(opts SchemaOpts) (*AnalyzedSchema, error) { if opts.Schema == nil { - return nil, errors.New("no schema to analyze") + return nil, ErrNoSchema } a := &AnalyzedSchema{ diff --git a/vendor/github.com/go-openapi/jsonpointer/.golangci.yml b/vendor/github.com/go-openapi/jsonpointer/.golangci.yml index 22f8d21..7cea1af 100644 --- a/vendor/github.com/go-openapi/jsonpointer/.golangci.yml +++ b/vendor/github.com/go-openapi/jsonpointer/.golangci.yml @@ -1,61 +1,75 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - nonamedreturns + - noinlineerr - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/jsonpointer/README.md b/vendor/github.com/go-openapi/jsonpointer/README.md index 0108f1d..45bd31b 100644 --- a/vendor/github.com/go-openapi/jsonpointer/README.md +++ b/vendor/github.com/go-openapi/jsonpointer/README.md @@ -13,7 +13,14 @@ Completed YES Tested YES ## References -http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07 + + + +also known as [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) ### Note + The 4.Evaluation part of the previous reference, starting with 'If the currently referenced value is a JSON array, the reference token MUST contain either...' is not implemented. + +That is because our implementation of the JSON pointer only supports explicit references to array elements: the provision in the spec +to resolve non-existent members as "the last element in the array", using the special trailing character "-". diff --git a/vendor/github.com/go-openapi/jsonpointer/errors.go b/vendor/github.com/go-openapi/jsonpointer/errors.go new file mode 100644 index 0000000..b84343d --- /dev/null +++ b/vendor/github.com/go-openapi/jsonpointer/errors.go @@ -0,0 +1,18 @@ +package jsonpointer + +type pointerError string + +func (e pointerError) Error() string { + return string(e) +} + +const ( + // ErrPointer is an error raised by the jsonpointer package + ErrPointer pointerError = "JSON pointer error" + + // ErrInvalidStart states that a JSON pointer must start with a separator ("/") + ErrInvalidStart pointerError = `JSON pointer must be empty or start with a "` + pointerSeparator + + // ErrUnsupportedValueType indicates that a value of the wrong type is being set + ErrUnsupportedValueType pointerError = "only structs, pointers, maps and slices are supported for setting values" +) diff --git a/vendor/github.com/go-openapi/jsonpointer/pointer.go b/vendor/github.com/go-openapi/jsonpointer/pointer.go index d970c7c..7513c47 100644 --- a/vendor/github.com/go-openapi/jsonpointer/pointer.go +++ b/vendor/github.com/go-openapi/jsonpointer/pointer.go @@ -33,19 +33,18 @@ import ( "strconv" "strings" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonname" ) const ( emptyPointer = `` pointerSeparator = `/` - - invalidStart = `JSON pointer must be empty or start with a "` + pointerSeparator - notFound = `Can't find the pointer in the document` ) -var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem() -var jsonSetableType = reflect.TypeOf(new(JSONSetable)).Elem() +var ( + jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem() + jsonSetableType = reflect.TypeOf(new(JSONSetable)).Elem() +) // JSONPointable is an interface for structs to implement when they need to customize the // json pointer process @@ -59,181 +58,104 @@ type JSONSetable interface { JSONSet(string, any) error } -// New creates a new json pointer for the given string -func New(jsonPointerString string) (Pointer, error) { - - var p Pointer - err := p.parse(jsonPointerString) - return p, err - -} - -// Pointer the json pointer reprsentation +// Pointer is a representation of a json pointer type Pointer struct { referenceTokens []string } -// "Constructor", parses the given string JSON pointer -func (p *Pointer) parse(jsonPointerString string) error { - - var err error - - if jsonPointerString != emptyPointer { - if !strings.HasPrefix(jsonPointerString, pointerSeparator) { - err = errors.New(invalidStart) - } else { - referenceTokens := strings.Split(jsonPointerString, pointerSeparator) - p.referenceTokens = append(p.referenceTokens, referenceTokens[1:]...) - } - } +// New creates a new json pointer for the given string +func New(jsonPointerString string) (Pointer, error) { + var p Pointer + err := p.parse(jsonPointerString) - return err + return p, err } // Get uses the pointer to retrieve a value from a JSON document func (p *Pointer) Get(document any) (any, reflect.Kind, error) { - return p.get(document, swag.DefaultJSONNameProvider) + return p.get(document, jsonname.DefaultJSONNameProvider) } // Set uses the pointer to set a value from a JSON document func (p *Pointer) Set(document any, value any) (any, error) { - return document, p.set(document, value, swag.DefaultJSONNameProvider) -} - -// GetForToken gets a value for a json pointer token 1 level deep -func GetForToken(document any, decodedToken string) (any, reflect.Kind, error) { - return getSingleImpl(document, decodedToken, swag.DefaultJSONNameProvider) -} - -// SetForToken gets a value for a json pointer token 1 level deep -func SetForToken(document any, decodedToken string, value any) (any, error) { - return document, setSingleImpl(document, value, decodedToken, swag.DefaultJSONNameProvider) + return document, p.set(document, value, jsonname.DefaultJSONNameProvider) } -func isNil(input any) bool { - if input == nil { - return true +// DecodedTokens returns the decoded tokens of this JSON pointer +func (p *Pointer) DecodedTokens() []string { + result := make([]string, 0, len(p.referenceTokens)) + for _, t := range p.referenceTokens { + result = append(result, Unescape(t)) } + return result +} - kind := reflect.TypeOf(input).Kind() - switch kind { //nolint:exhaustive - case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan: - return reflect.ValueOf(input).IsNil() - default: - return false - } +// IsEmpty returns true if this is an empty json pointer +// this indicates that it points to the root document +func (p *Pointer) IsEmpty() bool { + return len(p.referenceTokens) == 0 } -func getSingleImpl(node any, decodedToken string, nameProvider *swag.NameProvider) (any, reflect.Kind, error) { - rValue := reflect.Indirect(reflect.ValueOf(node)) - kind := rValue.Kind() - if isNil(node) { - return nil, kind, fmt.Errorf("nil value has not field %q", decodedToken) - } +// Pointer to string representation function +func (p *Pointer) String() string { - switch typed := node.(type) { - case JSONPointable: - r, err := typed.JSONLookup(decodedToken) - if err != nil { - return nil, kind, err - } - return r, kind, nil - case *any: // case of a pointer to interface, that is not resolved by reflect.Indirect - return getSingleImpl(*typed, decodedToken, nameProvider) + if len(p.referenceTokens) == 0 { + return emptyPointer } - switch kind { //nolint:exhaustive - case reflect.Struct: - nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) - if !ok { - return nil, kind, fmt.Errorf("object has no field %q", decodedToken) - } - fld := rValue.FieldByName(nm) - return fld.Interface(), kind, nil - - case reflect.Map: - kv := reflect.ValueOf(decodedToken) - mv := rValue.MapIndex(kv) - - if mv.IsValid() { - return mv.Interface(), kind, nil - } - return nil, kind, fmt.Errorf("object has no key %q", decodedToken) + return pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator) +} - case reflect.Slice: - tokenIndex, err := strconv.Atoi(decodedToken) +func (p *Pointer) Offset(document string) (int64, error) { + dec := json.NewDecoder(strings.NewReader(document)) + var offset int64 + for _, ttk := range p.DecodedTokens() { + tk, err := dec.Token() if err != nil { - return nil, kind, err + return 0, err } - sLength := rValue.Len() - if tokenIndex < 0 || tokenIndex >= sLength { - return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength-1, tokenIndex) + switch tk := tk.(type) { + case json.Delim: + switch tk { + case '{': + offset, err = offsetSingleObject(dec, ttk) + if err != nil { + return 0, err + } + case '[': + offset, err = offsetSingleArray(dec, ttk) + if err != nil { + return 0, err + } + default: + return 0, fmt.Errorf("invalid token %#v: %w", tk, ErrPointer) + } + default: + return 0, fmt.Errorf("invalid token %#v: %w", tk, ErrPointer) } - - elem := rValue.Index(tokenIndex) - return elem.Interface(), kind, nil - - default: - return nil, kind, fmt.Errorf("invalid token reference %q", decodedToken) } - + return offset, nil } -func setSingleImpl(node, data any, decodedToken string, nameProvider *swag.NameProvider) error { - rValue := reflect.Indirect(reflect.ValueOf(node)) - - if ns, ok := node.(JSONSetable); ok { // pointer impl - return ns.JSONSet(decodedToken, data) - } - - if rValue.Type().Implements(jsonSetableType) { - return node.(JSONSetable).JSONSet(decodedToken, data) - } - - switch rValue.Kind() { //nolint:exhaustive - case reflect.Struct: - nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) - if !ok { - return fmt.Errorf("object has no field %q", decodedToken) - } - fld := rValue.FieldByName(nm) - if fld.IsValid() { - fld.Set(reflect.ValueOf(data)) - } - return nil - - case reflect.Map: - kv := reflect.ValueOf(decodedToken) - rValue.SetMapIndex(kv, reflect.ValueOf(data)) - return nil - - case reflect.Slice: - tokenIndex, err := strconv.Atoi(decodedToken) - if err != nil { - return err - } - sLength := rValue.Len() - if tokenIndex < 0 || tokenIndex >= sLength { - return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex) - } +// "Constructor", parses the given string JSON pointer +func (p *Pointer) parse(jsonPointerString string) error { + var err error - elem := rValue.Index(tokenIndex) - if !elem.CanSet() { - return fmt.Errorf("can't set slice index %s to %v", decodedToken, data) + if jsonPointerString != emptyPointer { + if !strings.HasPrefix(jsonPointerString, pointerSeparator) { + err = errors.Join(ErrInvalidStart, ErrPointer) + } else { + referenceTokens := strings.Split(jsonPointerString, pointerSeparator) + p.referenceTokens = append(p.referenceTokens, referenceTokens[1:]...) } - elem.Set(reflect.ValueOf(data)) - return nil - - default: - return fmt.Errorf("invalid token reference %q", decodedToken) } + return err } -func (p *Pointer) get(node any, nameProvider *swag.NameProvider) (any, reflect.Kind, error) { - +func (p *Pointer) get(node any, nameProvider *jsonname.NameProvider) (any, reflect.Kind, error) { if nameProvider == nil { - nameProvider = swag.DefaultJSONNameProvider + nameProvider = jsonname.DefaultJSONNameProvider } kind := reflect.Invalid @@ -244,7 +166,6 @@ func (p *Pointer) get(node any, nameProvider *swag.NameProvider) (any, reflect.K } for _, token := range p.referenceTokens { - decodedToken := Unescape(token) r, knd, err := getSingleImpl(node, decodedToken, nameProvider) @@ -260,15 +181,18 @@ func (p *Pointer) get(node any, nameProvider *swag.NameProvider) (any, reflect.K return node, kind, nil } -func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { +func (p *Pointer) set(node, data any, nameProvider *jsonname.NameProvider) error { knd := reflect.ValueOf(node).Kind() - if knd != reflect.Ptr && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array { - return errors.New("only structs, pointers, maps and slices are supported for setting values") + if knd != reflect.Pointer && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array { + return errors.Join( + ErrUnsupportedValueType, + ErrPointer, + ) } if nameProvider == nil { - nameProvider = swag.DefaultJSONNameProvider + nameProvider = jsonname.DefaultJSONNameProvider } // Full document when empty @@ -286,6 +210,11 @@ func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { return setSingleImpl(node, data, decodedToken, nameProvider) } + // Check for nil during traversal + if isNil(node) { + return fmt.Errorf("cannot traverse through nil value at %q: %w", decodedToken, ErrPointer) + } + rValue := reflect.Indirect(reflect.ValueOf(node)) kind := rValue.Kind() @@ -295,7 +224,7 @@ func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { return err } fld := reflect.ValueOf(r) - if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr { + if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Pointer { node = fld.Addr().Interface() continue } @@ -307,10 +236,10 @@ func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { case reflect.Struct: nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) if !ok { - return fmt.Errorf("object has no field %q", decodedToken) + return fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer) } fld := rValue.FieldByName(nm) - if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr { + if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Pointer { node = fld.Addr().Interface() continue } @@ -321,9 +250,9 @@ func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { mv := rValue.MapIndex(kv) if !mv.IsValid() { - return fmt.Errorf("object has no key %q", decodedToken) + return fmt.Errorf("object has no key %q: %w", decodedToken, ErrPointer) } - if mv.CanAddr() && mv.Kind() != reflect.Interface && mv.Kind() != reflect.Map && mv.Kind() != reflect.Slice && mv.Kind() != reflect.Ptr { + if mv.CanAddr() && mv.Kind() != reflect.Interface && mv.Kind() != reflect.Map && mv.Kind() != reflect.Slice && mv.Kind() != reflect.Pointer { node = mv.Addr().Interface() continue } @@ -336,81 +265,155 @@ func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error { } sLength := rValue.Len() if tokenIndex < 0 || tokenIndex >= sLength { - return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex) + return fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength, tokenIndex, ErrPointer) } elem := rValue.Index(tokenIndex) - if elem.CanAddr() && elem.Kind() != reflect.Interface && elem.Kind() != reflect.Map && elem.Kind() != reflect.Slice && elem.Kind() != reflect.Ptr { + if elem.CanAddr() && elem.Kind() != reflect.Interface && elem.Kind() != reflect.Map && elem.Kind() != reflect.Slice && elem.Kind() != reflect.Pointer { node = elem.Addr().Interface() continue } node = elem.Interface() default: - return fmt.Errorf("invalid token reference %q", decodedToken) + return fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer) } - } return nil } -// DecodedTokens returns the decoded tokens -func (p *Pointer) DecodedTokens() []string { - result := make([]string, 0, len(p.referenceTokens)) - for _, t := range p.referenceTokens { - result = append(result, Unescape(t)) +func isNil(input any) bool { + if input == nil { + return true + } + + kind := reflect.TypeOf(input).Kind() + switch kind { //nolint:exhaustive + case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Chan: + return reflect.ValueOf(input).IsNil() + default: + return false } - return result } -// IsEmpty returns true if this is an empty json pointer -// this indicates that it points to the root document -func (p *Pointer) IsEmpty() bool { - return len(p.referenceTokens) == 0 +// GetForToken gets a value for a json pointer token 1 level deep +func GetForToken(document any, decodedToken string) (any, reflect.Kind, error) { + return getSingleImpl(document, decodedToken, jsonname.DefaultJSONNameProvider) } -// Pointer to string representation function -func (p *Pointer) String() string { +// SetForToken gets a value for a json pointer token 1 level deep +func SetForToken(document any, decodedToken string, value any) (any, error) { + return document, setSingleImpl(document, value, decodedToken, jsonname.DefaultJSONNameProvider) +} - if len(p.referenceTokens) == 0 { - return emptyPointer +func getSingleImpl(node any, decodedToken string, nameProvider *jsonname.NameProvider) (any, reflect.Kind, error) { + rValue := reflect.Indirect(reflect.ValueOf(node)) + kind := rValue.Kind() + if isNil(node) { + return nil, kind, fmt.Errorf("nil value has no field %q: %w", decodedToken, ErrPointer) } - pointerString := pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator) + switch typed := node.(type) { + case JSONPointable: + r, err := typed.JSONLookup(decodedToken) + if err != nil { + return nil, kind, err + } + return r, kind, nil + case *any: // case of a pointer to interface, that is not resolved by reflect.Indirect + return getSingleImpl(*typed, decodedToken, nameProvider) + } - return pointerString + switch kind { //nolint:exhaustive + case reflect.Struct: + nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) + if !ok { + return nil, kind, fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer) + } + fld := rValue.FieldByName(nm) + return fld.Interface(), kind, nil + + case reflect.Map: + kv := reflect.ValueOf(decodedToken) + mv := rValue.MapIndex(kv) + + if mv.IsValid() { + return mv.Interface(), kind, nil + } + return nil, kind, fmt.Errorf("object has no key %q: %w", decodedToken, ErrPointer) + + case reflect.Slice: + tokenIndex, err := strconv.Atoi(decodedToken) + if err != nil { + return nil, kind, err + } + sLength := rValue.Len() + if tokenIndex < 0 || tokenIndex >= sLength { + return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength-1, tokenIndex, ErrPointer) + } + + elem := rValue.Index(tokenIndex) + return elem.Interface(), kind, nil + + default: + return nil, kind, fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer) + } } -func (p *Pointer) Offset(document string) (int64, error) { - dec := json.NewDecoder(strings.NewReader(document)) - var offset int64 - for _, ttk := range p.DecodedTokens() { - tk, err := dec.Token() +func setSingleImpl(node, data any, decodedToken string, nameProvider *jsonname.NameProvider) error { + rValue := reflect.Indirect(reflect.ValueOf(node)) + + // Check for nil to prevent panic when calling rValue.Type() + if isNil(node) { + return fmt.Errorf("cannot set field %q on nil value: %w", decodedToken, ErrPointer) + } + + if ns, ok := node.(JSONSetable); ok { // pointer impl + return ns.JSONSet(decodedToken, data) + } + + if rValue.Type().Implements(jsonSetableType) { + return node.(JSONSetable).JSONSet(decodedToken, data) + } + + switch rValue.Kind() { //nolint:exhaustive + case reflect.Struct: + nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken) + if !ok { + return fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer) + } + fld := rValue.FieldByName(nm) + if fld.IsValid() { + fld.Set(reflect.ValueOf(data)) + } + return nil + + case reflect.Map: + kv := reflect.ValueOf(decodedToken) + rValue.SetMapIndex(kv, reflect.ValueOf(data)) + return nil + + case reflect.Slice: + tokenIndex, err := strconv.Atoi(decodedToken) if err != nil { - return 0, err + return err } - switch tk := tk.(type) { - case json.Delim: - switch tk { - case '{': - offset, err = offsetSingleObject(dec, ttk) - if err != nil { - return 0, err - } - case '[': - offset, err = offsetSingleArray(dec, ttk) - if err != nil { - return 0, err - } - default: - return 0, fmt.Errorf("invalid token %#v", tk) - } - default: - return 0, fmt.Errorf("invalid token %#v", tk) + sLength := rValue.Len() + if tokenIndex < 0 || tokenIndex >= sLength { + return fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength, tokenIndex, ErrPointer) } + + elem := rValue.Index(tokenIndex) + if !elem.CanSet() { + return fmt.Errorf("can't set slice index %s to %v: %w", decodedToken, data, ErrPointer) + } + elem.Set(reflect.ValueOf(data)) + return nil + + default: + return fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer) } - return offset, nil } func offsetSingleObject(dec *json.Decoder, decodedToken string) (int64, error) { @@ -437,16 +440,16 @@ func offsetSingleObject(dec *json.Decoder, decodedToken string) (int64, error) { return offset, nil } default: - return 0, fmt.Errorf("invalid token %#v", tk) + return 0, fmt.Errorf("invalid token %#v: %w", tk, ErrPointer) } } - return 0, fmt.Errorf("token reference %q not found", decodedToken) + return 0, fmt.Errorf("token reference %q not found: %w", decodedToken, ErrPointer) } func offsetSingleArray(dec *json.Decoder, decodedToken string) (int64, error) { idx, err := strconv.Atoi(decodedToken) if err != nil { - return 0, fmt.Errorf("token reference %q is not a number: %v", decodedToken, err) + return 0, fmt.Errorf("token reference %q is not a number: %v: %w", decodedToken, err, ErrPointer) } var i int for i = 0; i < idx && dec.More(); i++ { @@ -470,7 +473,7 @@ func offsetSingleArray(dec *json.Decoder, decodedToken string) (int64, error) { } if !dec.More() { - return 0, fmt.Errorf("token reference %q not found", decodedToken) + return 0, fmt.Errorf("token reference %q not found: %w", decodedToken, ErrPointer) } return dec.InputOffset(), nil } @@ -516,16 +519,17 @@ const ( decRefTok1 = `/` ) +var ( + encRefTokReplacer = strings.NewReplacer(encRefTok1, decRefTok1, encRefTok0, decRefTok0) + decRefTokReplacer = strings.NewReplacer(decRefTok1, encRefTok1, decRefTok0, encRefTok0) +) + // Unescape unescapes a json pointer reference token string to the original representation func Unescape(token string) string { - step1 := strings.ReplaceAll(token, encRefTok1, decRefTok1) - step2 := strings.ReplaceAll(step1, encRefTok0, decRefTok0) - return step2 + return encRefTokReplacer.Replace(token) } // Escape escapes a pointer reference token string func Escape(token string) string { - step1 := strings.ReplaceAll(token, decRefTok0, encRefTok0) - step2 := strings.ReplaceAll(step1, decRefTok1, encRefTok1) - return step2 + return decRefTokReplacer.Replace(token) } diff --git a/vendor/github.com/go-openapi/jsonreference/.golangci.yml b/vendor/github.com/go-openapi/jsonreference/.golangci.yml index 22f8d21..7cea1af 100644 --- a/vendor/github.com/go-openapi/jsonreference/.golangci.yml +++ b/vendor/github.com/go-openapi/jsonreference/.golangci.yml @@ -1,61 +1,75 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - nonamedreturns + - noinlineerr - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/jsonreference/reference.go b/vendor/github.com/go-openapi/jsonreference/reference.go index cfdef03..6a1fed5 100644 --- a/vendor/github.com/go-openapi/jsonreference/reference.go +++ b/vendor/github.com/go-openapi/jsonreference/reference.go @@ -38,13 +38,25 @@ const ( fragmentRune = `#` ) +var ErrChildURL = errors.New("child url is nil") + +// Ref represents a json reference object +type Ref struct { + referenceURL *url.URL + referencePointer jsonpointer.Pointer + + HasFullURL bool + HasURLPathOnly bool + HasFragmentOnly bool + HasFileScheme bool + HasFullFilePath bool +} + // New creates a new reference for the given string func New(jsonReferenceString string) (Ref, error) { - var r Ref err := r.parse(jsonReferenceString) return r, err - } // MustCreateRef parses the ref string and panics when it's invalid. @@ -54,19 +66,8 @@ func MustCreateRef(ref string) Ref { if err != nil { panic(err) } - return r -} -// Ref represents a json reference object -type Ref struct { - referenceURL *url.URL - referencePointer jsonpointer.Pointer - - HasFullURL bool - HasURLPathOnly bool - HasFragmentOnly bool - HasFileScheme bool - HasFullFilePath bool + return r } // GetURL gets the URL for this reference @@ -81,7 +82,6 @@ func (r *Ref) GetPointer() *jsonpointer.Pointer { // String returns the best version of the url for this reference func (r *Ref) String() string { - if r.referenceURL != nil { return r.referenceURL.String() } @@ -106,9 +106,27 @@ func (r *Ref) IsCanonical() bool { return (r.HasFileScheme && r.HasFullFilePath) || (!r.HasFileScheme && r.HasFullURL) } +// Inherits creates a new reference from a parent and a child +// If the child cannot inherit from the parent, an error is returned +func (r *Ref) Inherits(child Ref) (*Ref, error) { + childURL := child.GetURL() + parentURL := r.GetURL() + if childURL == nil { + return nil, ErrChildURL + } + if parentURL == nil { + return &child, nil + } + + ref, err := New(parentURL.ResolveReference(childURL).String()) + if err != nil { + return nil, err + } + return &ref, nil +} + // "Constructor", parses the given string JSON reference func (r *Ref) parse(jsonReferenceString string) error { - parsed, err := url.Parse(jsonReferenceString) if err != nil { return err @@ -137,22 +155,3 @@ func (r *Ref) parse(jsonReferenceString string) error { return nil } - -// Inherits creates a new reference from a parent and a child -// If the child cannot inherit from the parent, an error is returned -func (r *Ref) Inherits(child Ref) (*Ref, error) { - childURL := child.GetURL() - parentURL := r.GetURL() - if childURL == nil { - return nil, errors.New("child url is nil") - } - if parentURL == nil { - return &child, nil - } - - ref, err := New(parentURL.ResolveReference(childURL).String()) - if err != nil { - return nil, err - } - return &ref, nil -} diff --git a/vendor/github.com/go-openapi/loads/.golangci.yml b/vendor/github.com/go-openapi/loads/.golangci.yml index 22f8d21..7cea1af 100644 --- a/vendor/github.com/go-openapi/loads/.golangci.yml +++ b/vendor/github.com/go-openapi/loads/.golangci.yml @@ -1,61 +1,75 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - nonamedreturns + - noinlineerr - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/loads/README.md b/vendor/github.com/go-openapi/loads/README.md index f8bd440..6164ebe 100644 --- a/vendor/github.com/go-openapi/loads/README.md +++ b/vendor/github.com/go-openapi/loads/README.md @@ -3,4 +3,26 @@ [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/loads/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/loads?status.svg)](http://godoc.org/github.com/go-openapi/loads) [![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/loads)](https://goreportcard.com/report/github.com/go-openapi/loads) -Loading of OAI specification documents from local or remote locations. Supports JSON and YAML documents. +Loading of OAI v2 API specification documents from local or remote locations. Supports JSON and YAML documents. + +Primary usage: + +```go + import ( + "github.com/go-openapi/loads" + ) + + ... + + // loads a YAML spec from a http file + doc, err := loads.Spec(ts.URL) + + ... + + // retrieves the object model for the API specification + spec := doc.Spec() + + ... +``` + +See also the provided [examples](https://pkg.go.dev/github.com/go-openapi/loads#pkg-examples). diff --git a/vendor/github.com/go-openapi/loads/doc.go b/vendor/github.com/go-openapi/loads/doc.go index 5bcaef5..1ca47bc 100644 --- a/vendor/github.com/go-openapi/loads/doc.go +++ b/vendor/github.com/go-openapi/loads/doc.go @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package loads provides document loading methods for swagger (OAI) specifications. +// Package loads provides document loading methods for swagger (OAI v2) API specifications. // // It is used by other go-openapi packages to load and run analysis on local or remote spec documents. package loads diff --git a/vendor/github.com/go-openapi/loads/errors.go b/vendor/github.com/go-openapi/loads/errors.go new file mode 100644 index 0000000..132a702 --- /dev/null +++ b/vendor/github.com/go-openapi/loads/errors.go @@ -0,0 +1,15 @@ +package loads + +type loaderError string + +func (e loaderError) Error() string { + return string(e) +} + +const ( + // ErrLoads is an error returned by the loads package + ErrLoads loaderError = "loaderrs error" + + // ErrNoLoader indicates that no configured loader matched the input + ErrNoLoader loaderError = "no loader matched" +) diff --git a/vendor/github.com/go-openapi/loads/loaders.go b/vendor/github.com/go-openapi/loads/loaders.go index b2d1e03..646d35a 100644 --- a/vendor/github.com/go-openapi/loads/loaders.go +++ b/vendor/github.com/go-openapi/loads/loaders.go @@ -4,9 +4,10 @@ import ( "encoding/json" "errors" "net/url" + "slices" "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/loading" ) var ( @@ -30,8 +31,8 @@ func init() { loaders = jsonLoader.WithHead(&loader{ DocLoaderWithMatch: DocLoaderWithMatch{ - Match: swag.YAMLMatcher, - Fn: swag.YAMLDoc, + Match: loading.YAMLMatcher, + Fn: loading.YAMLDoc, }, }) @@ -40,7 +41,7 @@ func init() { } // DocLoader represents a doc loader type -type DocLoader func(string) (json.RawMessage, error) +type DocLoader func(string, ...loading.Option) (json.RawMessage, error) // DocMatcher represents a predicate to check if a loader matches type DocMatcher func(string) bool @@ -61,6 +62,9 @@ func NewDocLoaderWithMatch(fn DocLoader, matcher DocMatcher) DocLoaderWithMatch type loader struct { DocLoaderWithMatch + + loadingOptions []loading.Option + Next *loader } @@ -83,17 +87,17 @@ func (l *loader) WithNext(next *loader) *loader { func (l *loader) Load(path string) (json.RawMessage, error) { _, erp := url.Parse(path) if erp != nil { - return nil, erp + return nil, errors.Join(erp, ErrLoads) } - lastErr := errors.New("no loader matched") // default error if no match was found + var lastErr error = ErrNoLoader // default error if no match was found for ldr := l; ldr != nil; ldr = ldr.Next { if ldr.Match != nil && !ldr.Match(path) { continue } // try then move to next one if there is an error - b, err := ldr.Fn(path) + b, err := ldr.Fn(path, l.loadingOptions...) if err == nil { return b, nil } @@ -101,14 +105,29 @@ func (l *loader) Load(path string) (json.RawMessage, error) { lastErr = err } - return nil, lastErr + return nil, errors.Join(lastErr, ErrLoads) +} + +func (l *loader) clone() *loader { + if l == nil { + return nil + } + + return &loader{ + DocLoaderWithMatch: l.DocLoaderWithMatch, + loadingOptions: slices.Clone(l.loadingOptions), + Next: l.Next.clone(), + } } -// JSONDoc loads a json document from either a file or a remote url -func JSONDoc(path string) (json.RawMessage, error) { - data, err := swag.LoadFromFileOrHTTP(path) +// JSONDoc loads a json document from either a file or a remote url. +// +// See [loading.Option] for available options (e.g. configuring authentifaction, +// headers or using embedded file system resources). +func JSONDoc(path string, opts ...loading.Option) (json.RawMessage, error) { + data, err := loading.LoadFromFileOrHTTP(path, opts...) if err != nil { - return nil, err + return nil, errors.Join(err, ErrLoads) } return json.RawMessage(data), nil } diff --git a/vendor/github.com/go-openapi/loads/options.go b/vendor/github.com/go-openapi/loads/options.go index f8305d5..3b05531 100644 --- a/vendor/github.com/go-openapi/loads/options.go +++ b/vendor/github.com/go-openapi/loads/options.go @@ -1,7 +1,10 @@ package loads +import "github.com/go-openapi/swag/loading" + type options struct { - loader *loader + loader *loader + loadingOptions []loading.Option } func defaultOptions() *options { @@ -16,7 +19,10 @@ func loaderFromOptions(options []LoaderOption) *loader { apply(opts) } - return opts.loader + l := opts.loader.clone() + l.loadingOptions = opts.loadingOptions + + return l } // LoaderOption allows to fine-tune the spec loader behavior @@ -59,3 +65,10 @@ func WithDocLoaderMatches(l ...DocLoaderWithMatch) LoaderOption { opt.loader = final } } + +// WithLoadingOptions adds some [loading.Option] to be added when calling a registered loader. +func WithLoadingOptions(loadingOptions ...loading.Option) LoaderOption { + return func(opt *options) { + opt.loadingOptions = loadingOptions + } +} diff --git a/vendor/github.com/go-openapi/loads/spec.go b/vendor/github.com/go-openapi/loads/spec.go index c9039cd..838231a 100644 --- a/vendor/github.com/go-openapi/loads/spec.go +++ b/vendor/github.com/go-openapi/loads/spec.go @@ -18,16 +18,18 @@ import ( "bytes" "encoding/gob" "encoding/json" + "errors" "fmt" + "maps" "github.com/go-openapi/analysis" "github.com/go-openapi/spec" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/yamlutils" ) func init() { - gob.Register(map[string]interface{}{}) - gob.Register([]interface{}{}) + gob.Register(map[string]any{}) + gob.Register([]any{}) } // Document represents a swagger spec document @@ -42,14 +44,21 @@ type Document struct { raw json.RawMessage } -// JSONSpec loads a spec from a json document -func JSONSpec(path string, options ...LoaderOption) (*Document, error) { - data, err := JSONDoc(path) +// JSONSpec loads a spec from a json document, using the [JSONDoc] loader. +// +// A set of [loading.Option] may be passed to this loader using [WithLoadingOptions]. +func JSONSpec(path string, opts ...LoaderOption) (*Document, error) { + var o options + for _, apply := range opts { + apply(&o) + } + + data, err := JSONDoc(path, o.loadingOptions...) if err != nil { return nil, err } // convert to json - doc, err := Analyzed(data, "", options...) + doc, err := Analyzed(data, "", opts...) if err != nil { return nil, err } @@ -59,8 +68,8 @@ func JSONSpec(path string, options ...LoaderOption) (*Document, error) { return doc, nil } -// Embedded returns a Document based on embedded specs. No analysis is required -func Embedded(orig, flat json.RawMessage, options ...LoaderOption) (*Document, error) { +// Embedded returns a Document based on embedded specs (i.e. as a raw [json.RawMessage]). No analysis is required +func Embedded(orig, flat json.RawMessage, opts ...LoaderOption) (*Document, error) { var origSpec, flatSpec spec.Swagger if err := json.Unmarshal(orig, &origSpec); err != nil { return nil, err @@ -72,20 +81,22 @@ func Embedded(orig, flat json.RawMessage, options ...LoaderOption) (*Document, e raw: orig, origSpec: &origSpec, spec: &flatSpec, - pathLoader: loaderFromOptions(options), + pathLoader: loaderFromOptions(opts), }, nil } -// Spec loads a new spec document from a local or remote path -func Spec(path string, options ...LoaderOption) (*Document, error) { - ldr := loaderFromOptions(options) +// Spec loads a new spec document from a local or remote path. +// +// By default it uses a JSON or YAML loader, with auto-detection based on the resource extension. +func Spec(path string, opts ...LoaderOption) (*Document, error) { + ldr := loaderFromOptions(opts) b, err := ldr.Load(path) if err != nil { return nil, err } - document, err := Analyzed(b, "", options...) + document, err := Analyzed(b, "", opts...) if err != nil { return nil, err } @@ -102,7 +113,7 @@ func Analyzed(data json.RawMessage, version string, options ...LoaderOption) (*D version = "2.0" } if version != "2.0" { - return nil, fmt.Errorf("spec version %q is not supported", version) + return nil, fmt.Errorf("spec version %q is not supported: %w", version, ErrLoads) } raw, err := trimData(data) // trim blanks, then convert yaml docs into json @@ -112,12 +123,12 @@ func Analyzed(data json.RawMessage, version string, options ...LoaderOption) (*D swspec := new(spec.Swagger) if err = json.Unmarshal(raw, swspec); err != nil { - return nil, err + return nil, errors.Join(err, ErrLoads) } origsqspec, err := cloneSpec(swspec) if err != nil { - return nil, err + return nil, errors.Join(err, ErrLoads) } d := &Document{ @@ -143,20 +154,20 @@ func trimData(in json.RawMessage) (json.RawMessage, error) { } // assume yaml doc: convert it to json - yml, err := swag.BytesToYAMLDoc(trimmed) + yml, err := yamlutils.BytesToYAMLDoc(trimmed) if err != nil { - return nil, fmt.Errorf("analyzed: %v", err) + return nil, fmt.Errorf("analyzed: %v: %w", err, ErrLoads) } - d, err := swag.YAMLToJSON(yml) + d, err := yamlutils.YAMLToJSON(yml) if err != nil { - return nil, fmt.Errorf("analyzed: %v", err) + return nil, fmt.Errorf("analyzed: %v: %w", err, ErrLoads) } return d, nil } -// Expanded expands the $ref fields in the spec document and returns a new spec document +// Expanded expands the $ref fields in the spec [Document] and returns a new expanded [Document] func (d *Document) Expanded(options ...*spec.ExpandOptions) (*Document, error) { swspec := new(spec.Swagger) if err := json.Unmarshal(d.raw, swspec); err != nil { @@ -202,20 +213,23 @@ func (d *Document) Expanded(options ...*spec.ExpandOptions) (*Document, error) { // BasePath the base path for the API specified by this spec func (d *Document) BasePath() string { + if d.spec == nil { + return "" + } return d.spec.BasePath } -// Version returns the version of this spec +// Version returns the OpenAPI version of this spec (e.g. 2.0) func (d *Document) Version() string { return d.spec.Swagger } -// Schema returns the swagger 2.0 schema +// Schema returns the swagger 2.0 meta-schema func (d *Document) Schema() *spec.Schema { return d.schema } -// Spec returns the swagger spec object model +// Spec returns the swagger object model for this API specification func (d *Document) Spec() *spec.Swagger { return d.spec } @@ -235,14 +249,11 @@ func (d *Document) OrigSpec() *spec.Swagger { return d.origSpec } -// ResetDefinitions gives a shallow copy with the models reset to the original spec +// ResetDefinitions yields a shallow copy with the models reset to the original spec func (d *Document) ResetDefinitions() *Document { - defs := make(map[string]spec.Schema, len(d.origSpec.Definitions)) - for k, v := range d.origSpec.Definitions { - defs[k] = v - } + d.spec.Definitions = make(map[string]spec.Schema, len(d.origSpec.Definitions)) + maps.Copy(d.spec.Definitions, d.origSpec.Definitions) - d.spec.Definitions = defs return d } @@ -271,5 +282,6 @@ func cloneSpec(src *spec.Swagger) (*spec.Swagger, error) { if err := gob.NewDecoder(&b).Decode(&dst); err != nil { return nil, err } + return &dst, nil } diff --git a/vendor/github.com/go-openapi/spec/.golangci.yml b/vendor/github.com/go-openapi/spec/.golangci.yml index 22f8d21..7cea1af 100644 --- a/vendor/github.com/go-openapi/spec/.golangci.yml +++ b/vendor/github.com/go-openapi/spec/.golangci.yml @@ -1,61 +1,75 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - nonamedreturns + - noinlineerr - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/spec/contact_info.go b/vendor/github.com/go-openapi/spec/contact_info.go index 2f7bb21..3eaa41e 100644 --- a/vendor/github.com/go-openapi/spec/contact_info.go +++ b/vendor/github.com/go-openapi/spec/contact_info.go @@ -17,7 +17,7 @@ package spec import ( "encoding/json" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // ContactInfo contact information for the exposed API. @@ -53,5 +53,5 @@ func (c ContactInfo) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } diff --git a/vendor/github.com/go-openapi/spec/errors.go b/vendor/github.com/go-openapi/spec/errors.go index 6992c7b..718b4ae 100644 --- a/vendor/github.com/go-openapi/spec/errors.go +++ b/vendor/github.com/go-openapi/spec/errors.go @@ -16,4 +16,7 @@ var ( // ErrExpandUnsupportedType indicates that $ref expansion is attempted on some invalid type ErrExpandUnsupportedType = errors.New("expand: unsupported type. Input should be of type *Parameter or *Response") + + // ErrSpec is an error raised by the spec package + ErrSpec = errors.New("spec error") ) diff --git a/vendor/github.com/go-openapi/spec/expander.go b/vendor/github.com/go-openapi/spec/expander.go index b81a569..df936b3 100644 --- a/vendor/github.com/go-openapi/spec/expander.go +++ b/vendor/github.com/go-openapi/spec/expander.go @@ -19,6 +19,8 @@ import ( "fmt" ) +const smallPrealloc = 10 + // ExpandOptions provides options for the spec expander. // // RelativeBase is the path to the root document. This can be a remote URL or a path to a local file. @@ -56,7 +58,7 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) error { if !options.SkipSchemas { for key, definition := range spec.Definitions { - parentRefs := make([]string, 0, 10) + parentRefs := make([]string, 0, smallPrealloc) parentRefs = append(parentRefs, "#/definitions/"+key) def, err := expandSchema(definition, parentRefs, resolver, specBasePath) @@ -160,7 +162,7 @@ func ExpandSchemaWithBasePath(schema *Schema, cache ResolutionCache, opts *Expan resolver := defaultSchemaLoader(nil, opts, cache, nil) - parentRefs := make([]string, 0, 10) + parentRefs := make([]string, 0, smallPrealloc) s, err := expandSchema(*schema, parentRefs, resolver, opts.RelativeBase) if err != nil { return err @@ -386,7 +388,7 @@ func expandPathItem(pathItem *PathItem, resolver *schemaLoader, basePath string) return nil } - parentRefs := make([]string, 0, 10) + parentRefs := make([]string, 0, smallPrealloc) if err := resolver.deref(pathItem, parentRefs, basePath); resolver.shouldStopOnError(err) { return err } @@ -546,7 +548,7 @@ func expandParameterOrResponse(input interface{}, resolver *schemaLoader, basePa return nil } - parentRefs := make([]string, 0, 10) + parentRefs := make([]string, 0, smallPrealloc) if ref != nil { // dereference this $ref if err = resolver.deref(input, parentRefs, basePath); resolver.shouldStopOnError(err) { diff --git a/vendor/github.com/go-openapi/spec/header.go b/vendor/github.com/go-openapi/spec/header.go index 9dfd17b..55c415e 100644 --- a/vendor/github.com/go-openapi/spec/header.go +++ b/vendor/github.com/go-openapi/spec/header.go @@ -19,7 +19,7 @@ import ( "strings" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) const ( @@ -74,14 +74,14 @@ func (h *Header) WithDefault(defaultValue interface{}) *Header { } // WithMaxLength sets a max length value -func (h *Header) WithMaxLength(max int64) *Header { - h.MaxLength = &max +func (h *Header) WithMaxLength(maximum int64) *Header { + h.MaxLength = &maximum return h } // WithMinLength sets a min length value -func (h *Header) WithMinLength(min int64) *Header { - h.MinLength = &min +func (h *Header) WithMinLength(minimum int64) *Header { + h.MinLength = &minimum return h } @@ -98,15 +98,15 @@ func (h *Header) WithMultipleOf(number float64) *Header { } // WithMaximum sets a maximum number value -func (h *Header) WithMaximum(max float64, exclusive bool) *Header { - h.Maximum = &max +func (h *Header) WithMaximum(maximum float64, exclusive bool) *Header { + h.Maximum = &maximum h.ExclusiveMaximum = exclusive return h } // WithMinimum sets a minimum number value -func (h *Header) WithMinimum(min float64, exclusive bool) *Header { - h.Minimum = &min +func (h *Header) WithMinimum(minimum float64, exclusive bool) *Header { + h.Minimum = &minimum h.ExclusiveMinimum = exclusive return h } @@ -161,7 +161,7 @@ func (h Header) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2, b3), nil + return jsonutils.ConcatJSON(b1, b2, b3), nil } // UnmarshalJSON unmarshals this header from JSON diff --git a/vendor/github.com/go-openapi/spec/info.go b/vendor/github.com/go-openapi/spec/info.go index 582f0fd..695cd9a 100644 --- a/vendor/github.com/go-openapi/spec/info.go +++ b/vendor/github.com/go-openapi/spec/info.go @@ -20,7 +20,7 @@ import ( "strings" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // Extensions vendor specific extensions @@ -172,7 +172,7 @@ func (i Info) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON diff --git a/vendor/github.com/go-openapi/spec/items.go b/vendor/github.com/go-openapi/spec/items.go index e2afb21..0224673 100644 --- a/vendor/github.com/go-openapi/spec/items.go +++ b/vendor/github.com/go-openapi/spec/items.go @@ -19,7 +19,7 @@ import ( "strings" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) const ( @@ -97,14 +97,14 @@ func (i *Items) WithDefault(defaultValue interface{}) *Items { } // WithMaxLength sets a max length value -func (i *Items) WithMaxLength(max int64) *Items { - i.MaxLength = &max +func (i *Items) WithMaxLength(maximum int64) *Items { + i.MaxLength = &maximum return i } // WithMinLength sets a min length value -func (i *Items) WithMinLength(min int64) *Items { - i.MinLength = &min +func (i *Items) WithMinLength(minimum int64) *Items { + i.MinLength = &minimum return i } @@ -121,15 +121,15 @@ func (i *Items) WithMultipleOf(number float64) *Items { } // WithMaximum sets a maximum number value -func (i *Items) WithMaximum(max float64, exclusive bool) *Items { - i.Maximum = &max +func (i *Items) WithMaximum(maximum float64, exclusive bool) *Items { + i.Maximum = &maximum i.ExclusiveMaximum = exclusive return i } // WithMinimum sets a minimum number value -func (i *Items) WithMinimum(min float64, exclusive bool) *Items { - i.Minimum = &min +func (i *Items) WithMinimum(minimum float64, exclusive bool) *Items { + i.Minimum = &minimum i.ExclusiveMinimum = exclusive return i } @@ -213,7 +213,7 @@ func (i Items) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b4, b3, b1, b2), nil + return jsonutils.ConcatJSON(b4, b3, b1, b2), nil } // JSONLookup look up a value by the json property name diff --git a/vendor/github.com/go-openapi/spec/license.go b/vendor/github.com/go-openapi/spec/license.go index b42f803..09f54fe 100644 --- a/vendor/github.com/go-openapi/spec/license.go +++ b/vendor/github.com/go-openapi/spec/license.go @@ -17,7 +17,7 @@ package spec import ( "encoding/json" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // License information for the exposed API. @@ -52,5 +52,5 @@ func (l License) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } diff --git a/vendor/github.com/go-openapi/spec/operation.go b/vendor/github.com/go-openapi/spec/operation.go index a69cca8..9826219 100644 --- a/vendor/github.com/go-openapi/spec/operation.go +++ b/vendor/github.com/go-openapi/spec/operation.go @@ -21,12 +21,12 @@ import ( "sort" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) func init() { - gob.Register(map[string]interface{}{}) - gob.Register([]interface{}{}) + gob.Register(map[string]any{}) + gob.Register([]any{}) } // OperationProps describes an operation @@ -58,19 +58,22 @@ func (op OperationProps) MarshalJSON() ([]byte, error) { type Alias OperationProps if op.Security == nil { return json.Marshal(&struct { - Security []map[string][]string `json:"security,omitempty"` *Alias + + Security []map[string][]string `json:"security,omitempty"` }{ - Security: op.Security, Alias: (*Alias)(&op), + Security: op.Security, }) } + return json.Marshal(&struct { - Security []map[string][]string `json:"security"` *Alias + + Security []map[string][]string `json:"security"` }{ - Security: op.Security, Alias: (*Alias)(&op), + Security: op.Security, }) } @@ -82,6 +85,14 @@ type Operation struct { OperationProps } +// NewOperation creates a new operation instance. +// It expects an ID as parameter but not passing an ID is also valid. +func NewOperation(id string) *Operation { + op := new(Operation) + op.ID = id + return op +} + // SuccessResponse gets a success response model func (o *Operation) SuccessResponse() (*Response, int, bool) { if o.Responses == nil { @@ -104,7 +115,7 @@ func (o *Operation) SuccessResponse() (*Response, int, bool) { } // JSONLookup look up a value by the json property name -func (o Operation) JSONLookup(token string) (interface{}, error) { +func (o Operation) JSONLookup(token string) (any, error) { if ex, ok := o.Extensions[token]; ok { return &ex, nil } @@ -130,18 +141,10 @@ func (o Operation) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - concated := swag.ConcatJSON(b1, b2) + concated := jsonutils.ConcatJSON(b1, b2) return concated, nil } -// NewOperation creates a new operation instance. -// It expects an ID as parameter but not passing an ID is also valid. -func NewOperation(id string) *Operation { - op := new(Operation) - op.ID = id - return op -} - // WithID sets the ID property on this operation, allows for chaining. func (o *Operation) WithID(id string) *Operation { o.ID = id diff --git a/vendor/github.com/go-openapi/spec/parameter.go b/vendor/github.com/go-openapi/spec/parameter.go index bd4f1cd..1dd8311 100644 --- a/vendor/github.com/go-openapi/spec/parameter.go +++ b/vendor/github.com/go-openapi/spec/parameter.go @@ -19,7 +19,7 @@ import ( "strings" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // QueryParam creates a query parameter @@ -210,14 +210,14 @@ func (p *Parameter) AsRequired() *Parameter { } // WithMaxLength sets a max length value -func (p *Parameter) WithMaxLength(max int64) *Parameter { - p.MaxLength = &max +func (p *Parameter) WithMaxLength(maximum int64) *Parameter { + p.MaxLength = &maximum return p } // WithMinLength sets a min length value -func (p *Parameter) WithMinLength(min int64) *Parameter { - p.MinLength = &min +func (p *Parameter) WithMinLength(minimum int64) *Parameter { + p.MinLength = &minimum return p } @@ -234,15 +234,15 @@ func (p *Parameter) WithMultipleOf(number float64) *Parameter { } // WithMaximum sets a maximum number value -func (p *Parameter) WithMaximum(max float64, exclusive bool) *Parameter { - p.Maximum = &max +func (p *Parameter) WithMaximum(maximum float64, exclusive bool) *Parameter { + p.Maximum = &maximum p.ExclusiveMaximum = exclusive return p } // WithMinimum sets a minimum number value -func (p *Parameter) WithMinimum(min float64, exclusive bool) *Parameter { - p.Minimum = &min +func (p *Parameter) WithMinimum(minimum float64, exclusive bool) *Parameter { + p.Minimum = &minimum p.ExclusiveMinimum = exclusive return p } @@ -322,5 +322,5 @@ func (p Parameter) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b3, b1, b2, b4, b5), nil + return jsonutils.ConcatJSON(b3, b1, b2, b4, b5), nil } diff --git a/vendor/github.com/go-openapi/spec/path_item.go b/vendor/github.com/go-openapi/spec/path_item.go index 68fc8e9..e51b810 100644 --- a/vendor/github.com/go-openapi/spec/path_item.go +++ b/vendor/github.com/go-openapi/spec/path_item.go @@ -18,7 +18,7 @@ import ( "encoding/json" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // PathItemProps the path item specific properties @@ -82,6 +82,6 @@ func (p PathItem) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - concated := swag.ConcatJSON(b3, b4, b5) + concated := jsonutils.ConcatJSON(b3, b4, b5) return concated, nil } diff --git a/vendor/github.com/go-openapi/spec/paths.go b/vendor/github.com/go-openapi/spec/paths.go index 9dc82a2..b95eadc 100644 --- a/vendor/github.com/go-openapi/spec/paths.go +++ b/vendor/github.com/go-openapi/spec/paths.go @@ -19,7 +19,7 @@ import ( "fmt" "strings" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // Paths holds the relative paths to the individual endpoints. @@ -30,18 +30,19 @@ import ( // For more information: http://goo.gl/8us55a#pathsObject type Paths struct { VendorExtensible + Paths map[string]PathItem `json:"-"` // custom serializer to flatten this, each entry must start with "/" } // JSONLookup look up a value by the json property name -func (p Paths) JSONLookup(token string) (interface{}, error) { +func (p Paths) JSONLookup(token string) (any, error) { if pi, ok := p.Paths[token]; ok { return &pi, nil } if ex, ok := p.Extensions[token]; ok { return &ex, nil } - return nil, fmt.Errorf("object has no field %q", token) + return nil, fmt.Errorf("object has no field %q: %w", token, ErrSpec) } // UnmarshalJSON hydrates this items instance with the data from JSON @@ -53,9 +54,9 @@ func (p *Paths) UnmarshalJSON(data []byte) error { for k, v := range res { if strings.HasPrefix(strings.ToLower(k), "x-") { if p.Extensions == nil { - p.Extensions = make(map[string]interface{}) + p.Extensions = make(map[string]any) } - var d interface{} + var d any if err := json.Unmarshal(v, &d); err != nil { return err } @@ -92,6 +93,6 @@ func (p Paths) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - concated := swag.ConcatJSON(b1, b2) + concated := jsonutils.ConcatJSON(b1, b2) return concated, nil } diff --git a/vendor/github.com/go-openapi/spec/properties.go b/vendor/github.com/go-openapi/spec/properties.go index 91d2435..ada68dd 100644 --- a/vendor/github.com/go-openapi/spec/properties.go +++ b/vendor/github.com/go-openapi/spec/properties.go @@ -9,8 +9,9 @@ import ( // OrderSchemaItem holds a named schema (e.g. from a property of an object) type OrderSchemaItem struct { - Name string Schema + + Name string } // OrderSchemaItems is a sortable slice of named schemas. diff --git a/vendor/github.com/go-openapi/spec/ref.go b/vendor/github.com/go-openapi/spec/ref.go index b0ef9bd..87b8b3a 100644 --- a/vendor/github.com/go-openapi/spec/ref.go +++ b/vendor/github.com/go-openapi/spec/ref.go @@ -45,6 +45,23 @@ type Ref struct { jsonreference.Ref } +// NewRef creates a new instance of a ref object +// returns an error when the reference uri is an invalid uri +func NewRef(refURI string) (Ref, error) { + ref, err := jsonreference.New(refURI) + if err != nil { + return Ref{}, err + } + + return Ref{Ref: ref}, nil +} + +// MustCreateRef creates a ref object but panics when refURI is invalid. +// Use the NewRef method for a version that returns an error. +func MustCreateRef(refURI string) Ref { + return Ref{Ref: jsonreference.MustCreateRef(refURI)} +} + // RemoteURI gets the remote uri part of the ref func (r *Ref) RemoteURI() string { if r.String() == "" { @@ -75,10 +92,11 @@ func (r *Ref) IsValidURI(basepaths ...string) bool { } defer rr.Body.Close() - return rr.StatusCode/100 == 2 + // true if the response is >= 200 and < 300 + return rr.StatusCode/100 == 2 //nolint:mnd } - if !(r.HasFileScheme || r.HasFullFilePath || r.HasURLPathOnly) { + if !r.HasFileScheme && !r.HasFullFilePath && !r.HasURLPathOnly { return false } @@ -114,22 +132,6 @@ func (r *Ref) Inherits(child Ref) (*Ref, error) { return &Ref{Ref: *ref}, nil } -// NewRef creates a new instance of a ref object -// returns an error when the reference uri is an invalid uri -func NewRef(refURI string) (Ref, error) { - ref, err := jsonreference.New(refURI) - if err != nil { - return Ref{}, err - } - return Ref{Ref: ref}, nil -} - -// MustCreateRef creates a ref object but panics when refURI is invalid. -// Use the NewRef method for a version that returns an error. -func MustCreateRef(refURI string) Ref { - return Ref{Ref: jsonreference.MustCreateRef(refURI)} -} - // MarshalJSON marshals this ref into a JSON object func (r Ref) MarshalJSON() ([]byte, error) { str := r.String() @@ -139,13 +141,13 @@ func (r Ref) MarshalJSON() ([]byte, error) { } return []byte("{}"), nil } - v := map[string]interface{}{"$ref": str} + v := map[string]any{"$ref": str} return json.Marshal(v) } // UnmarshalJSON unmarshals this ref from a JSON object func (r *Ref) UnmarshalJSON(d []byte) error { - var v map[string]interface{} + var v map[string]any if err := json.Unmarshal(d, &v); err != nil { return err } @@ -174,7 +176,7 @@ func (r *Ref) GobDecode(b []byte) error { return json.Unmarshal(raw, r) } -func (r *Ref) fromMap(v map[string]interface{}) error { +func (r *Ref) fromMap(v map[string]any) error { if v == nil { return nil } diff --git a/vendor/github.com/go-openapi/spec/resolver.go b/vendor/github.com/go-openapi/spec/resolver.go index 47d1ee1..dd577b0 100644 --- a/vendor/github.com/go-openapi/spec/resolver.go +++ b/vendor/github.com/go-openapi/spec/resolver.go @@ -3,7 +3,7 @@ package spec import ( "fmt" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) func resolveAnyWithBase(root interface{}, ref *Ref, result interface{}, options *ExpandOptions) error { @@ -45,7 +45,7 @@ func ResolveRef(root interface{}, ref *Ref) (*Schema, error) { return sch, nil case map[string]interface{}: newSch := new(Schema) - if err = swag.DynamicJSONToStruct(sch, newSch); err != nil { + if err = jsonutils.FromDynamicJSON(sch, newSch); err != nil { return nil, err } return newSch, nil diff --git a/vendor/github.com/go-openapi/spec/response.go b/vendor/github.com/go-openapi/spec/response.go index 0340b60..edb60a5 100644 --- a/vendor/github.com/go-openapi/spec/response.go +++ b/vendor/github.com/go-openapi/spec/response.go @@ -18,7 +18,7 @@ import ( "encoding/json" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // ResponseProps properties specific to a response @@ -38,6 +38,18 @@ type Response struct { VendorExtensible } +// NewResponse creates a new response instance +func NewResponse() *Response { + return new(Response) +} + +// ResponseRef creates a response as a json reference +func ResponseRef(url string) *Response { + resp := NewResponse() + resp.Ref = MustCreateRef(url) + return resp +} + // JSONLookup look up a value by the json property name func (r Response) JSONLookup(token string) (interface{}, error) { if ex, ok := r.Extensions[token]; ok { @@ -79,9 +91,9 @@ func (r Response) MarshalJSON() ([]byte, error) { Headers map[string]Header `json:"headers,omitempty"` Examples map[string]interface{} `json:"examples,omitempty"` }{ - Description: r.ResponseProps.Description, - Schema: r.ResponseProps.Schema, - Examples: r.ResponseProps.Examples, + Description: r.Description, + Schema: r.Schema, + Examples: r.Examples, }) } if err != nil { @@ -96,19 +108,7 @@ func (r Response) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2, b3), nil -} - -// NewResponse creates a new response instance -func NewResponse() *Response { - return new(Response) -} - -// ResponseRef creates a response as a json reference -func ResponseRef(url string) *Response { - resp := NewResponse() - resp.Ref = MustCreateRef(url) - return resp + return jsonutils.ConcatJSON(b1, b2, b3), nil } // WithDescription sets the description on this response, allows for chaining diff --git a/vendor/github.com/go-openapi/spec/responses.go b/vendor/github.com/go-openapi/spec/responses.go index 16c3076..337c6b1 100644 --- a/vendor/github.com/go-openapi/spec/responses.go +++ b/vendor/github.com/go-openapi/spec/responses.go @@ -21,7 +21,7 @@ import ( "strconv" "strings" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // Responses is a container for the expected responses of an operation. @@ -55,7 +55,7 @@ func (r Responses) JSONLookup(token string) (interface{}, error) { return scr, nil } } - return nil, fmt.Errorf("object has no field %q", token) + return nil, fmt.Errorf("object has no field %q: %w", token, ErrSpec) } // UnmarshalJSON hydrates this items instance with the data from JSON @@ -83,7 +83,7 @@ func (r Responses) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - concated := swag.ConcatJSON(b1, b2) + concated := jsonutils.ConcatJSON(b1, b2) return concated, nil } diff --git a/vendor/github.com/go-openapi/spec/schema.go b/vendor/github.com/go-openapi/spec/schema.go index 4e9be85..0a49f2d 100644 --- a/vendor/github.com/go-openapi/spec/schema.go +++ b/vendor/github.com/go-openapi/spec/schema.go @@ -20,7 +20,8 @@ import ( "strings" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonname" + "github.com/go-openapi/swag/jsonutils" ) // BooleanProperty creates a boolean property @@ -125,20 +126,20 @@ func (r SchemaURL) MarshalJSON() ([]byte, error) { if r == "" { return []byte("{}"), nil } - v := map[string]interface{}{"$schema": string(r)} + v := map[string]any{"$schema": string(r)} return json.Marshal(v) } // UnmarshalJSON unmarshal this from JSON func (r *SchemaURL) UnmarshalJSON(data []byte) error { - var v map[string]interface{} + var v map[string]any if err := json.Unmarshal(data, &v); err != nil { return err } return r.fromMap(v) } -func (r *SchemaURL) fromMap(v map[string]interface{}) error { +func (r *SchemaURL) fromMap(v map[string]any) error { if v == nil { return nil } @@ -165,7 +166,7 @@ type SchemaProps struct { Nullable bool `json:"nullable,omitempty"` Format string `json:"format,omitempty"` Title string `json:"title,omitempty"` - Default interface{} `json:"default,omitempty"` + Default any `json:"default,omitempty"` Maximum *float64 `json:"maximum,omitempty"` ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"` Minimum *float64 `json:"minimum,omitempty"` @@ -177,7 +178,7 @@ type SchemaProps struct { MinItems *int64 `json:"minItems,omitempty"` UniqueItems bool `json:"uniqueItems,omitempty"` MultipleOf *float64 `json:"multipleOf,omitempty"` - Enum []interface{} `json:"enum,omitempty"` + Enum []any `json:"enum,omitempty"` MaxProperties *int64 `json:"maxProperties,omitempty"` MinProperties *int64 `json:"minProperties,omitempty"` Required []string `json:"required,omitempty"` @@ -200,7 +201,7 @@ type SwaggerSchemaProps struct { ReadOnly bool `json:"readOnly,omitempty"` XML *XMLObject `json:"xml,omitempty"` ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` - Example interface{} `json:"example,omitempty"` + Example any `json:"example,omitempty"` } // Schema the schema object allows the definition of input and output data types. @@ -214,11 +215,12 @@ type Schema struct { VendorExtensible SchemaProps SwaggerSchemaProps - ExtraProps map[string]interface{} `json:"-"` + + ExtraProps map[string]any `json:"-"` } // JSONLookup implements an interface to customize json pointer lookup -func (s Schema) JSONLookup(token string) (interface{}, error) { +func (s Schema) JSONLookup(token string) (any, error) { if ex, ok := s.Extensions[token]; ok { return &ex, nil } @@ -275,14 +277,14 @@ func (s *Schema) WithAllOf(schemas ...Schema) *Schema { } // WithMaxProperties sets the max number of properties an object can have -func (s *Schema) WithMaxProperties(max int64) *Schema { - s.MaxProperties = &max +func (s *Schema) WithMaxProperties(maximum int64) *Schema { + s.MaxProperties = &maximum return s } // WithMinProperties sets the min number of properties an object must have -func (s *Schema) WithMinProperties(min int64) *Schema { - s.MinProperties = &min +func (s *Schema) WithMinProperties(minimum int64) *Schema { + s.MinProperties = &minimum return s } @@ -316,7 +318,7 @@ func (s *Schema) CollectionOf(items Schema) *Schema { } // WithDefault sets the default value on this parameter -func (s *Schema) WithDefault(defaultValue interface{}) *Schema { +func (s *Schema) WithDefault(defaultValue any) *Schema { s.Default = defaultValue return s } @@ -334,14 +336,14 @@ func (s *Schema) AddRequired(items ...string) *Schema { } // WithMaxLength sets a max length value -func (s *Schema) WithMaxLength(max int64) *Schema { - s.MaxLength = &max +func (s *Schema) WithMaxLength(maximum int64) *Schema { + s.MaxLength = &maximum return s } // WithMinLength sets a min length value -func (s *Schema) WithMinLength(min int64) *Schema { - s.MinLength = &min +func (s *Schema) WithMinLength(minimum int64) *Schema { + s.MinLength = &minimum return s } @@ -358,22 +360,22 @@ func (s *Schema) WithMultipleOf(number float64) *Schema { } // WithMaximum sets a maximum number value -func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema { - s.Maximum = &max +func (s *Schema) WithMaximum(maximum float64, exclusive bool) *Schema { + s.Maximum = &maximum s.ExclusiveMaximum = exclusive return s } // WithMinimum sets a minimum number value -func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema { - s.Minimum = &min +func (s *Schema) WithMinimum(minimum float64, exclusive bool) *Schema { + s.Minimum = &minimum s.ExclusiveMinimum = exclusive return s } // WithEnum sets a the enum values (replace) -func (s *Schema) WithEnum(values ...interface{}) *Schema { - s.Enum = append([]interface{}{}, values...) +func (s *Schema) WithEnum(values ...any) *Schema { + s.Enum = append([]any{}, values...) return s } @@ -426,7 +428,7 @@ func (s *Schema) AsWritable() *Schema { } // WithExample sets the example for this schema -func (s *Schema) WithExample(example interface{}) *Schema { +func (s *Schema) WithExample(example any) *Schema { s.Example = example return s } @@ -566,33 +568,33 @@ func (s Schema) Validations() SchemaValidations { func (s Schema) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(s.SchemaProps) if err != nil { - return nil, fmt.Errorf("schema props %v", err) + return nil, fmt.Errorf("schema props %v: %w", err, ErrSpec) } b2, err := json.Marshal(s.VendorExtensible) if err != nil { - return nil, fmt.Errorf("vendor props %v", err) + return nil, fmt.Errorf("vendor props %v: %w", err, ErrSpec) } b3, err := s.Ref.MarshalJSON() if err != nil { - return nil, fmt.Errorf("ref prop %v", err) + return nil, fmt.Errorf("ref prop %v: %w", err, ErrSpec) } b4, err := s.Schema.MarshalJSON() if err != nil { - return nil, fmt.Errorf("schema prop %v", err) + return nil, fmt.Errorf("schema prop %v: %w", err, ErrSpec) } b5, err := json.Marshal(s.SwaggerSchemaProps) if err != nil { - return nil, fmt.Errorf("common validations %v", err) + return nil, fmt.Errorf("common validations %v: %w", err, ErrSpec) } var b6 []byte if s.ExtraProps != nil { jj, err := json.Marshal(s.ExtraProps) if err != nil { - return nil, fmt.Errorf("extra props %v", err) + return nil, fmt.Errorf("extra props %v: %w", err, ErrSpec) } b6 = jj } - return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil + return jsonutils.ConcatJSON(b1, b2, b3, b4, b5, b6), nil } // UnmarshalJSON marshal this from JSON @@ -610,7 +612,7 @@ func (s *Schema) UnmarshalJSON(data []byte) error { SwaggerSchemaProps: props.SwaggerSchemaProps, } - var d map[string]interface{} + var d map[string]any if err := json.Unmarshal(data, &d); err != nil { return err } @@ -620,7 +622,7 @@ func (s *Schema) UnmarshalJSON(data []byte) error { delete(d, "$ref") delete(d, "$schema") - for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) { + for _, pn := range jsonname.DefaultJSONNameProvider.GetJSONNames(s) { delete(d, pn) } @@ -628,13 +630,13 @@ func (s *Schema) UnmarshalJSON(data []byte) error { lk := strings.ToLower(k) if strings.HasPrefix(lk, "x-") { if sch.Extensions == nil { - sch.Extensions = map[string]interface{}{} + sch.Extensions = map[string]any{} } sch.Extensions[k] = vv continue } if sch.ExtraProps == nil { - sch.ExtraProps = map[string]interface{}{} + sch.ExtraProps = map[string]any{} } sch.ExtraProps[k] = vv } diff --git a/vendor/github.com/go-openapi/spec/schema_loader.go b/vendor/github.com/go-openapi/spec/schema_loader.go index 0059b99..328e5b8 100644 --- a/vendor/github.com/go-openapi/spec/schema_loader.go +++ b/vendor/github.com/go-openapi/spec/schema_loader.go @@ -22,7 +22,9 @@ import ( "reflect" "strings" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" + "github.com/go-openapi/swag/loading" + "github.com/go-openapi/swag/stringutils" ) // PathLoader is a function to use when loading remote refs. @@ -34,7 +36,7 @@ import ( // this value with its own default (a loader to retrieve YAML documents as // well as JSON ones). var PathLoader = func(pth string) (json.RawMessage, error) { - data, err := swag.LoadFromFileOrHTTP(pth) + data, err := loading.LoadFromFileOrHTTP(pth) if err != nil { return nil, err } @@ -73,12 +75,23 @@ func newResolverContext(options *ExpandOptions) *resolverContext { } type schemaLoader struct { - root interface{} + root any options *ExpandOptions cache ResolutionCache context *resolverContext } +// Resolve resolves a reference against basePath and stores the result in target. +// +// Resolve is not in charge of following references: it only resolves ref by following its URL. +// +// If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them. +// +// If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct +func (r *schemaLoader) Resolve(ref *Ref, target any, basePath string) error { + return r.resolveRef(ref, target, basePath) +} + func (r *schemaLoader) transitiveResolver(basePath string, ref Ref) *schemaLoader { if ref.IsRoot() || ref.HasFragmentOnly { return r @@ -113,7 +126,7 @@ func (r *schemaLoader) updateBasePath(transitive *schemaLoader, basePath string) return basePath } -func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string) error { +func (r *schemaLoader) resolveRef(ref *Ref, target any, basePath string) error { tgt := reflect.ValueOf(target) if tgt.Kind() != reflect.Ptr { return ErrResolveRefNeedsAPointer @@ -124,8 +137,8 @@ func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string) } var ( - res interface{} - data interface{} + res any + data any err error ) @@ -155,10 +168,10 @@ func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string) return err } } - return swag.DynamicJSONToStruct(res, target) + return jsonutils.FromDynamicJSON(res, target) } -func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) { +func (r *schemaLoader) load(refURL *url.URL) (any, url.URL, bool, error) { debugLog("loading schema from url: %s", refURL) toFetch := *refURL toFetch.Fragment = "" @@ -178,7 +191,7 @@ func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) return nil, url.URL{}, false, err } - var doc interface{} + var doc any if err := json.Unmarshal(b, &doc); err != nil { return nil, url.URL{}, false, err } @@ -197,25 +210,14 @@ func (r *schemaLoader) isCircular(ref *Ref, basePath string, parentRefs ...strin foundCycle = true return } - foundCycle = swag.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased + foundCycle = stringutils.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased if foundCycle { r.context.circulars[normalizedRef] = true } return } -// Resolve resolves a reference against basePath and stores the result in target. -// -// Resolve is not in charge of following references: it only resolves ref by following its URL. -// -// If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them. -// -// If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct -func (r *schemaLoader) Resolve(ref *Ref, target interface{}, basePath string) error { - return r.resolveRef(ref, target, basePath) -} - -func (r *schemaLoader) deref(input interface{}, parentRefs []string, basePath string) error { +func (r *schemaLoader) deref(input any, parentRefs []string, basePath string) error { var ref *Ref switch refable := input.(type) { case *Schema: @@ -267,7 +269,7 @@ func (r *schemaLoader) shouldStopOnError(err error) bool { return false } -func (r *schemaLoader) setSchemaID(target interface{}, id, basePath string) (string, string) { +func (r *schemaLoader) setSchemaID(target any, id, basePath string) (string, string) { debugLog("schema has ID: %s", id) // handling the case when id is a folder @@ -299,7 +301,7 @@ func (r *schemaLoader) setSchemaID(target interface{}, id, basePath string) (str } func defaultSchemaLoader( - root interface{}, + root any, expandOptions *ExpandOptions, cache ResolutionCache, context *resolverContext) *schemaLoader { diff --git a/vendor/github.com/go-openapi/spec/security_scheme.go b/vendor/github.com/go-openapi/spec/security_scheme.go index 9d0bdae..2dfe934 100644 --- a/vendor/github.com/go-openapi/spec/security_scheme.go +++ b/vendor/github.com/go-openapi/spec/security_scheme.go @@ -18,7 +18,7 @@ import ( "encoding/json" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) const ( @@ -158,7 +158,7 @@ func (s SecurityScheme) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON diff --git a/vendor/github.com/go-openapi/spec/swagger.go b/vendor/github.com/go-openapi/spec/swagger.go index 1590fd1..0e73759 100644 --- a/vendor/github.com/go-openapi/spec/swagger.go +++ b/vendor/github.com/go-openapi/spec/swagger.go @@ -22,7 +22,7 @@ import ( "strconv" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // Swagger this is the root document object for the API specification. @@ -54,7 +54,7 @@ func (s Swagger) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } // UnmarshalJSON unmarshals a swagger spec from json @@ -379,7 +379,7 @@ func (s *StringOrArray) UnmarshalJSON(data []byte) error { *s = StringOrArray([]string{v}) return nil default: - return fmt.Errorf("only string or array is allowed, not %T", single) + return fmt.Errorf("only string or array is allowed, not %T: %w", single, ErrSpec) } } diff --git a/vendor/github.com/go-openapi/spec/tag.go b/vendor/github.com/go-openapi/spec/tag.go index faa3d3d..baf1f3d 100644 --- a/vendor/github.com/go-openapi/spec/tag.go +++ b/vendor/github.com/go-openapi/spec/tag.go @@ -18,7 +18,7 @@ import ( "encoding/json" "github.com/go-openapi/jsonpointer" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // TagProps describe a tag entry in the top level tags section of a swagger spec @@ -28,11 +28,6 @@ type TagProps struct { ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"` } -// NewTag creates a new tag -func NewTag(name, description string, externalDocs *ExternalDocumentation) Tag { - return Tag{TagProps: TagProps{Description: description, Name: name, ExternalDocs: externalDocs}} -} - // Tag allows adding meta data to a single tag that is used by the // [Operation Object](http://goo.gl/8us55a#operationObject). // It is not mandatory to have a Tag Object per tag used there. @@ -43,6 +38,11 @@ type Tag struct { TagProps } +// NewTag creates a new tag +func NewTag(name, description string, externalDocs *ExternalDocumentation) Tag { + return Tag{TagProps: TagProps{Description: description, Name: name, ExternalDocs: externalDocs}} +} + // JSONLookup implements an interface to customize json pointer lookup func (t Tag) JSONLookup(token string) (interface{}, error) { if ex, ok := t.Extensions[token]; ok { @@ -63,7 +63,7 @@ func (t Tag) MarshalJSON() ([]byte, error) { if err != nil { return nil, err } - return swag.ConcatJSON(b1, b2), nil + return jsonutils.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON diff --git a/vendor/github.com/go-openapi/spec/validations.go b/vendor/github.com/go-openapi/spec/validations.go index 6360a8e..ae80a5d 100644 --- a/vendor/github.com/go-openapi/spec/validations.go +++ b/vendor/github.com/go-openapi/spec/validations.go @@ -54,7 +54,8 @@ func (c clearedValidations) apply(cbs []func(string, interface{})) { // // Some callbacks may be set by the caller to capture changed values. func (v *CommonValidations) ClearNumberValidations(cbs ...func(string, interface{})) { - done := make(clearedValidations, 0, 5) + const maxNumberValidations = 5 + done := make(clearedValidations, 0, maxNumberValidations) defer func() { done.apply(cbs) }() @@ -85,7 +86,8 @@ func (v *CommonValidations) ClearNumberValidations(cbs ...func(string, interface // // Some callbacks may be set by the caller to capture changed values. func (v *CommonValidations) ClearStringValidations(cbs ...func(string, interface{})) { - done := make(clearedValidations, 0, 3) + const maxStringValidations = 3 + done := make(clearedValidations, 0, maxStringValidations) defer func() { done.apply(cbs) }() @@ -108,7 +110,8 @@ func (v *CommonValidations) ClearStringValidations(cbs ...func(string, interface // // Some callbacks may be set by the caller to capture changed values. func (v *CommonValidations) ClearArrayValidations(cbs ...func(string, interface{})) { - done := make(clearedValidations, 0, 3) + const maxArrayValidations = 3 + done := make(clearedValidations, 0, maxArrayValidations) defer func() { done.apply(cbs) }() @@ -195,7 +198,8 @@ func (v SchemaValidations) Validations() SchemaValidations { // // Some callbacks may be set by the caller to capture changed values. func (v *SchemaValidations) ClearObjectValidations(cbs ...func(string, interface{})) { - done := make(clearedValidations, 0, 3) + const maxObjectValidations = 3 + done := make(clearedValidations, 0, maxObjectValidations) defer func() { done.apply(cbs) }() diff --git a/vendor/github.com/go-openapi/validate/.golangci.yml b/vendor/github.com/go-openapi/validate/.golangci.yml index 22f8d21..43e2576 100644 --- a/vendor/github.com/go-openapi/validate/.golangci.yml +++ b/vendor/github.com/go-openapi/validate/.golangci.yml @@ -1,61 +1,76 @@ -linters-settings: - govet: - check-shadowing: true - golint: - min-confidence: 0 - gocyclo: - min-complexity: 45 - maligned: - suggest-new: true - dupl: - threshold: 200 - goconst: - min-len: 2 - min-occurrences: 3 - +version: "2" linters: - enable-all: true + default: all disable: - - maligned - - unparam - - lll - - gochecknoinits - - gochecknoglobals + - cyclop + - depguard + - errchkjson + - errorlint + - exhaustruct + - forcetypeassert - funlen - - godox + - gochecknoglobals + - gochecknoinits - gocognit - - whitespace - - wsl - - wrapcheck - - testpackage - - nlreturn - - gomnd - - exhaustivestruct - - goerr113 - - errorlint - - nestif - godot - - gofumpt + - godox + - gomoddirectives + - gosmopolitan + - inamedparam + #- intrange # disabled while < go1.22 + - ireturn + - lll + - musttag + - nestif + - nlreturn + - nonamedreturns + - noinlineerr - paralleltest - - tparallel + - recvcheck + - testpackage - thelper - - ifshort - - exhaustruct + - tparallel + - unparam - varnamelen - - gci - - depguard - - errchkjson - - inamedparam - - nonamedreturns - - musttag - - ireturn - - forcetypeassert - - cyclop - # deprecated linters - - deadcode - - interfacer - - scopelint - - varcheck - - structcheck - - golint - - nosnakecase + - whitespace + - wrapcheck + - wsl + - wsl_v5 + settings: + dupl: + threshold: 200 + goconst: + min-len: 2 + min-occurrences: 3 + gocyclo: + min-complexity: 45 + exclusions: + generated: lax + presets: + - comments + - common-false-positives + - legacy + - std-error-handling + paths: + - third_party$ + - builtin$ + - examples$ +formatters: + enable: + - gofmt + - goimports + exclusions: + generated: lax + paths: + - third_party$ + - builtin$ + - examples$ +issues: + # Maximum issues count per one linter. + # Set to 0 to disable. + # Default: 50 + max-issues-per-linter: 0 + # Maximum count of issues with the same text. + # Set to 0 to disable. + # Default: 3 + max-same-issues: 0 diff --git a/vendor/github.com/go-openapi/validate/context.go b/vendor/github.com/go-openapi/validate/context.go index 8997717..d54791c 100644 --- a/vendor/github.com/go-openapi/validate/context.go +++ b/vendor/github.com/go-openapi/validate/context.go @@ -27,7 +27,7 @@ func WithOperationRequest(ctx context.Context) context.Context { return withOperation(ctx, request) } -// WithOperationRequest returns a new context with operationType response +// WithOperationResponse returns a new context with operationType response // in context value func WithOperationResponse(ctx context.Context) context.Context { return withOperation(ctx, response) diff --git a/vendor/github.com/go-openapi/validate/default_validator.go b/vendor/github.com/go-openapi/validate/default_validator.go index e0dd938..e82bb30 100644 --- a/vendor/github.com/go-openapi/validate/default_validator.go +++ b/vendor/github.com/go-openapi/validate/default_validator.go @@ -29,6 +29,18 @@ type defaultValidator struct { schemaOptions *SchemaValidatorOptions } +// Validate validates the default values declared in the swagger spec +func (d *defaultValidator) Validate() *Result { + errs := pools.poolOfResults.BorrowResult() // will redeem when merged + + if d == nil || d.SpecValidator == nil { + return errs + } + d.resetVisited() + errs.Merge(d.validateDefaultValueValidAgainstSchema()) // error - + return errs +} + // resetVisited resets the internal state of visited schemas func (d *defaultValidator) resetVisited() { if d.visitedSchemas == nil { @@ -54,7 +66,8 @@ func isVisited(path string, visitedSchemas map[string]struct{}) bool { parent string suffix string ) - for i := len(path) - 2; i >= 0; i-- { + const backtrackFromEnd = 2 + for i := len(path) - backtrackFromEnd; i >= 0; i-- { r := path[i] if r != '.' { continue @@ -81,18 +94,6 @@ func (d *defaultValidator) isVisited(path string) bool { return isVisited(path, d.visitedSchemas) } -// Validate validates the default values declared in the swagger spec -func (d *defaultValidator) Validate() *Result { - errs := pools.poolOfResults.BorrowResult() // will redeem when merged - - if d == nil || d.SpecValidator == nil { - return errs - } - d.resetVisited() - errs.Merge(d.validateDefaultValueValidAgainstSchema()) // error - - return errs -} - func (d *defaultValidator) validateDefaultValueValidAgainstSchema() *Result { // every default value that is specified must validate against the schema for that property // headers, items, parameters, schema @@ -284,7 +285,7 @@ func (d *defaultValidator) validateDefaultValueSchemaAgainstSchema(path, in stri // TODO: Temporary duplicated code. Need to refactor with examples -func (d *defaultValidator) validateDefaultValueItemsAgainstSchema(path, in string, root interface{}, items *spec.Items) *Result { +func (d *defaultValidator) validateDefaultValueItemsAgainstSchema(path, in string, root any, items *spec.Items) *Result { res := pools.poolOfResults.BorrowResult() s := d.SpecValidator if items != nil { diff --git a/vendor/github.com/go-openapi/validate/example_validator.go b/vendor/github.com/go-openapi/validate/example_validator.go index d089569..0663b21 100644 --- a/vendor/github.com/go-openapi/validate/example_validator.go +++ b/vendor/github.com/go-openapi/validate/example_validator.go @@ -27,6 +27,25 @@ type exampleValidator struct { schemaOptions *SchemaValidatorOptions } +// Validate validates the example values declared in the swagger spec +// Example values MUST conform to their schema. +// +// With Swagger 2.0, examples are supported in: +// - schemas +// - individual property +// - responses +func (ex *exampleValidator) Validate() *Result { + errs := pools.poolOfResults.BorrowResult() + + if ex == nil || ex.SpecValidator == nil { + return errs + } + ex.resetVisited() + errs.Merge(ex.validateExampleValueValidAgainstSchema()) // error - + + return errs +} + // resetVisited resets the internal state of visited schemas func (ex *exampleValidator) resetVisited() { if ex.visitedSchemas == nil { @@ -51,25 +70,6 @@ func (ex *exampleValidator) isVisited(path string) bool { return isVisited(path, ex.visitedSchemas) } -// Validate validates the example values declared in the swagger spec -// Example values MUST conform to their schema. -// -// With Swagger 2.0, examples are supported in: -// - schemas -// - individual property -// - responses -func (ex *exampleValidator) Validate() *Result { - errs := pools.poolOfResults.BorrowResult() - - if ex == nil || ex.SpecValidator == nil { - return errs - } - ex.resetVisited() - errs.Merge(ex.validateExampleValueValidAgainstSchema()) // error - - - return errs -} - func (ex *exampleValidator) validateExampleValueValidAgainstSchema() *Result { // every example value that is specified must validate against the schema for that property // in: schemas, properties, object, items @@ -278,7 +278,7 @@ func (ex *exampleValidator) validateExampleValueSchemaAgainstSchema(path, in str // TODO: Temporary duplicated code. Need to refactor with examples // -func (ex *exampleValidator) validateExampleValueItemsAgainstSchema(path, in string, root interface{}, items *spec.Items) *Result { +func (ex *exampleValidator) validateExampleValueItemsAgainstSchema(path, in string, root any, items *spec.Items) *Result { res := pools.poolOfResults.BorrowResult() s := ex.SpecValidator if items != nil { diff --git a/vendor/github.com/go-openapi/validate/helpers.go b/vendor/github.com/go-openapi/validate/helpers.go index 757e403..16840da 100644 --- a/vendor/github.com/go-openapi/validate/helpers.go +++ b/vendor/github.com/go-openapi/validate/helpers.go @@ -169,7 +169,7 @@ func (h *valueHelper) asInt64(val interface{}) int64 { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return v.Int() case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return int64(v.Uint()) + return int64(v.Uint()) //nolint:gosec case reflect.Float32, reflect.Float64: return int64(v.Float()) default: @@ -184,7 +184,7 @@ func (h *valueHelper) asUint64(val interface{}) uint64 { v := reflect.ValueOf(val) switch v.Kind() { //nolint:exhaustive case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return uint64(v.Int()) + return uint64(v.Int()) //nolint:gosec case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return v.Uint() case reflect.Float32, reflect.Float64: @@ -273,7 +273,7 @@ func (h *paramHelper) checkExpandedParam(pr *spec.Parameter, path, in, operation simpleZero := spec.SimpleSchema{} // Try to explain why... best guess switch { - case pr.In == swaggerBody && (pr.SimpleSchema != simpleZero && pr.SimpleSchema.Type != objectType): + case pr.In == swaggerBody && (pr.SimpleSchema != simpleZero && pr.Type != objectType): if isRef { // Most likely, a $ref with a sibling is an unwanted situation: in itself this is a warning... // but we detect it because of the following error: diff --git a/vendor/github.com/go-openapi/validate/object_validator.go b/vendor/github.com/go-openapi/validate/object_validator.go index dff73fa..76301d0 100644 --- a/vendor/github.com/go-openapi/validate/object_validator.go +++ b/vendor/github.com/go-openapi/validate/object_validator.go @@ -33,7 +33,7 @@ type objectValidator struct { Properties map[string]spec.Schema AdditionalProperties *spec.SchemaOrBool PatternProperties map[string]spec.Schema - Root interface{} + Root any KnownFormats strfmt.Registry Options *SchemaValidatorOptions splitPath []string @@ -42,7 +42,7 @@ type objectValidator struct { func newObjectValidator(path, in string, maxProperties, minProperties *int64, required []string, properties spec.SchemaProperties, additionalProperties *spec.SchemaOrBool, patternProperties spec.SchemaProperties, - root interface{}, formats strfmt.Registry, opts *SchemaValidatorOptions) *objectValidator { + root any, formats strfmt.Registry, opts *SchemaValidatorOptions) *objectValidator { if opts == nil { opts = new(SchemaValidatorOptions) } @@ -70,12 +70,76 @@ func newObjectValidator(path, in string, return v } +func (o *objectValidator) Validate(data any) *Result { + if o.Options.recycleValidators { + defer func() { + o.redeem() + }() + } + + var val map[string]any + if data != nil { + var ok bool + val, ok = data.(map[string]any) + if !ok { + return errorHelp.sErr(invalidObjectMsg(o.Path, o.In), o.Options.recycleResult) + } + } + numKeys := int64(len(val)) + + if o.MinProperties != nil && numKeys < *o.MinProperties { + return errorHelp.sErr(errors.TooFewProperties(o.Path, o.In, *o.MinProperties), o.Options.recycleResult) + } + if o.MaxProperties != nil && numKeys > *o.MaxProperties { + return errorHelp.sErr(errors.TooManyProperties(o.Path, o.In, *o.MaxProperties), o.Options.recycleResult) + } + + var res *Result + if o.Options.recycleResult { + res = pools.poolOfResults.BorrowResult() + } else { + res = new(Result) + } + + o.precheck(res, val) + + // check validity of field names + if o.AdditionalProperties != nil && !o.AdditionalProperties.Allows { + // Case: additionalProperties: false + o.validateNoAdditionalProperties(val, res) + } else { + // Cases: empty additionalProperties (implying: true), or additionalProperties: true, or additionalProperties: { <> } + o.validateAdditionalProperties(val, res) + } + + o.validatePropertiesSchema(val, res) + + // Check patternProperties + // TODO: it looks like we have done that twice in many cases + for key, value := range val { + _, regularProperty := o.Properties[key] + matched, _, patterns := o.validatePatternProperty(key, value, res) // applies to regular properties as well + if regularProperty || !matched { + continue + } + + for _, pName := range patterns { + if v, ok := o.PatternProperties[pName]; ok { + r := newSchemaValidator(&v, o.Root, o.Path+"."+key, o.KnownFormats, o.Options).Validate(value) + res.mergeForField(data.(map[string]any), key, r) + } + } + } + + return res +} + func (o *objectValidator) SetPath(path string) { o.Path = path o.splitPath = strings.Split(path, ".") } -func (o *objectValidator) Applies(source interface{}, kind reflect.Kind) bool { +func (o *objectValidator) Applies(source any, kind reflect.Kind) bool { // TODO: this should also work for structs // there is a problem in the type validator where it will be unhappy about null values // so that requires more testing @@ -98,7 +162,7 @@ func (o *objectValidator) isExample() bool { return len(p) > 1 && (p[len(p)-1] == swaggerExample || p[len(p)-1] == swaggerExamples) && p[len(p)-2] != swaggerExample } -func (o *objectValidator) checkArrayMustHaveItems(res *Result, val map[string]interface{}) { +func (o *objectValidator) checkArrayMustHaveItems(res *Result, val map[string]any) { // for swagger 2.0 schemas, there is an additional constraint to have array items defined explicitly. // with pure jsonschema draft 4, one may have arrays with undefined items (i.e. any type). if val == nil { @@ -123,7 +187,7 @@ func (o *objectValidator) checkArrayMustHaveItems(res *Result, val map[string]in res.AddErrors(errors.Required(jsonItems, o.Path, item)) } -func (o *objectValidator) checkItemsMustBeTypeArray(res *Result, val map[string]interface{}) { +func (o *objectValidator) checkItemsMustBeTypeArray(res *Result, val map[string]any) { if val == nil { return } @@ -148,7 +212,7 @@ func (o *objectValidator) checkItemsMustBeTypeArray(res *Result, val map[string] } } -func (o *objectValidator) precheck(res *Result, val map[string]interface{}) { +func (o *objectValidator) precheck(res *Result, val map[string]any) { if o.Options.EnableArrayMustHaveItemsCheck { o.checkArrayMustHaveItems(res, val) } @@ -157,71 +221,7 @@ func (o *objectValidator) precheck(res *Result, val map[string]interface{}) { } } -func (o *objectValidator) Validate(data interface{}) *Result { - if o.Options.recycleValidators { - defer func() { - o.redeem() - }() - } - - var val map[string]interface{} - if data != nil { - var ok bool - val, ok = data.(map[string]interface{}) - if !ok { - return errorHelp.sErr(invalidObjectMsg(o.Path, o.In), o.Options.recycleResult) - } - } - numKeys := int64(len(val)) - - if o.MinProperties != nil && numKeys < *o.MinProperties { - return errorHelp.sErr(errors.TooFewProperties(o.Path, o.In, *o.MinProperties), o.Options.recycleResult) - } - if o.MaxProperties != nil && numKeys > *o.MaxProperties { - return errorHelp.sErr(errors.TooManyProperties(o.Path, o.In, *o.MaxProperties), o.Options.recycleResult) - } - - var res *Result - if o.Options.recycleResult { - res = pools.poolOfResults.BorrowResult() - } else { - res = new(Result) - } - - o.precheck(res, val) - - // check validity of field names - if o.AdditionalProperties != nil && !o.AdditionalProperties.Allows { - // Case: additionalProperties: false - o.validateNoAdditionalProperties(val, res) - } else { - // Cases: empty additionalProperties (implying: true), or additionalProperties: true, or additionalProperties: { <> } - o.validateAdditionalProperties(val, res) - } - - o.validatePropertiesSchema(val, res) - - // Check patternProperties - // TODO: it looks like we have done that twice in many cases - for key, value := range val { - _, regularProperty := o.Properties[key] - matched, _, patterns := o.validatePatternProperty(key, value, res) // applies to regular properties as well - if regularProperty || !matched { - continue - } - - for _, pName := range patterns { - if v, ok := o.PatternProperties[pName]; ok { - r := newSchemaValidator(&v, o.Root, o.Path+"."+key, o.KnownFormats, o.Options).Validate(value) - res.mergeForField(data.(map[string]interface{}), key, r) - } - } - } - - return res -} - -func (o *objectValidator) validateNoAdditionalProperties(val map[string]interface{}, res *Result) { +func (o *objectValidator) validateNoAdditionalProperties(val map[string]any, res *Result) { for k := range val { if k == "$schema" || k == "id" { // special properties "$schema" and "id" are ignored @@ -266,7 +266,7 @@ func (o *objectValidator) validateNoAdditionalProperties(val map[string]interfac } // $ref is forbidden in header - headers, mapOk := val[k].(map[string]interface{}) + headers, mapOk := val[k].(map[string]any) if !mapOk { continue } @@ -276,7 +276,7 @@ func (o *objectValidator) validateNoAdditionalProperties(val map[string]interfac continue } - headerSchema, mapOfMapOk := headerBody.(map[string]interface{}) + headerSchema, mapOfMapOk := headerBody.(map[string]any) if !mapOfMapOk { continue } @@ -303,7 +303,7 @@ func (o *objectValidator) validateNoAdditionalProperties(val map[string]interfac } } -func (o *objectValidator) validateAdditionalProperties(val map[string]interface{}, res *Result) { +func (o *objectValidator) validateAdditionalProperties(val map[string]any, res *Result) { for key, value := range val { _, regularProperty := o.Properties[key] if regularProperty { @@ -331,7 +331,7 @@ func (o *objectValidator) validateAdditionalProperties(val map[string]interface{ // Valid cases: additionalProperties: true or undefined } -func (o *objectValidator) validatePropertiesSchema(val map[string]interface{}, res *Result) { +func (o *objectValidator) validatePropertiesSchema(val map[string]any, res *Result) { createdFromDefaults := map[string]struct{}{} // Property types: @@ -389,7 +389,7 @@ func (o *objectValidator) validatePropertiesSchema(val map[string]interface{}, r } // TODO: succeededOnce is not used anywhere -func (o *objectValidator) validatePatternProperty(key string, value interface{}, result *Result) (bool, bool, []string) { +func (o *objectValidator) validatePatternProperty(key string, value any, result *Result) (bool, bool, []string) { if len(o.PatternProperties) == 0 { return false, false, nil } diff --git a/vendor/github.com/go-openapi/validate/result.go b/vendor/github.com/go-openapi/validate/result.go index c80804a..1955cff 100644 --- a/vendor/github.com/go-openapi/validate/result.go +++ b/vendor/github.com/go-openapi/validate/result.go @@ -43,7 +43,7 @@ type Result struct { MatchCount int // the object data - data interface{} + data any // Schemata for the root object rootObjectSchemata schemata @@ -60,24 +60,24 @@ type Result struct { // FieldKey is a pair of an object and a field, usable as a key for a map. type FieldKey struct { - object reflect.Value // actually a map[string]interface{}, but the latter cannot be a key + object reflect.Value // actually a map[string]any, but the latter cannot be a key field string } // ItemKey is a pair of a slice and an index, usable as a key for a map. type ItemKey struct { - slice reflect.Value // actually a []interface{}, but the latter cannot be a key + slice reflect.Value // actually a []any, but the latter cannot be a key index int } // NewFieldKey returns a pair of an object and field usable as a key of a map. -func NewFieldKey(obj map[string]interface{}, field string) FieldKey { +func NewFieldKey(obj map[string]any, field string) FieldKey { return FieldKey{object: reflect.ValueOf(obj), field: field} } // Object returns the underlying object of this key. -func (fk *FieldKey) Object() map[string]interface{} { - return fk.object.Interface().(map[string]interface{}) +func (fk *FieldKey) Object() map[string]any { + return fk.object.Interface().(map[string]any) } // Field returns the underlying field of this key. @@ -86,13 +86,13 @@ func (fk *FieldKey) Field() string { } // NewItemKey returns a pair of a slice and index usable as a key of a map. -func NewItemKey(slice interface{}, i int) ItemKey { +func NewItemKey(slice any, i int) ItemKey { return ItemKey{slice: reflect.ValueOf(slice), index: i} } // Slice returns the underlying slice of this key. -func (ik *ItemKey) Slice() []interface{} { - return ik.slice.Interface().([]interface{}) +func (ik *ItemKey) Slice() []any { + return ik.slice.Interface().([]any) } // Index returns the underlying index of this key. @@ -101,7 +101,7 @@ func (ik *ItemKey) Index() int { } type fieldSchemata struct { - obj map[string]interface{} + obj map[string]any field string schemata schemata } @@ -129,7 +129,7 @@ func (r *Result) Merge(others ...*Result) *Result { // Data returns the original data object used for validation. Mutating this renders // the result invalid. -func (r *Result) Data() interface{} { +func (r *Result) Data() any { return r.data } @@ -177,6 +177,138 @@ func (r *Result) ItemSchemata() map[ItemKey][]*spec.Schema { return ret } +// MergeAsErrors merges this result with the other one(s), preserving match counts etc. +// +// Warnings from input are merged as Errors in the returned merged Result. +func (r *Result) MergeAsErrors(others ...*Result) *Result { + for _, other := range others { + if other != nil { + r.resetCaches() + r.AddErrors(other.Errors...) + r.AddErrors(other.Warnings...) + r.MatchCount += other.MatchCount + if other.wantsRedeemOnMerge { + pools.poolOfResults.RedeemResult(other) + } + } + } + return r +} + +// MergeAsWarnings merges this result with the other one(s), preserving match counts etc. +// +// Errors from input are merged as Warnings in the returned merged Result. +func (r *Result) MergeAsWarnings(others ...*Result) *Result { + for _, other := range others { + if other != nil { + r.resetCaches() + r.AddWarnings(other.Errors...) + r.AddWarnings(other.Warnings...) + r.MatchCount += other.MatchCount + if other.wantsRedeemOnMerge { + pools.poolOfResults.RedeemResult(other) + } + } + } + return r +} + +// AddErrors adds errors to this validation result (if not already reported). +// +// Since the same check may be passed several times while exploring the +// spec structure (via $ref, ...) reported messages are kept +// unique. +func (r *Result) AddErrors(errors ...error) { + for _, e := range errors { + found := false + if e != nil { + for _, isReported := range r.Errors { + if e.Error() == isReported.Error() { + found = true + break + } + } + if !found { + r.Errors = append(r.Errors, e) + } + } + } +} + +// AddWarnings adds warnings to this validation result (if not already reported). +func (r *Result) AddWarnings(warnings ...error) { + for _, e := range warnings { + found := false + if e != nil { + for _, isReported := range r.Warnings { + if e.Error() == isReported.Error() { + found = true + break + } + } + if !found { + r.Warnings = append(r.Warnings, e) + } + } + } +} + +// IsValid returns true when this result is valid. +// +// Returns true on a nil *Result. +func (r *Result) IsValid() bool { + if r == nil { + return true + } + return len(r.Errors) == 0 +} + +// HasErrors returns true when this result is invalid. +// +// Returns false on a nil *Result. +func (r *Result) HasErrors() bool { + if r == nil { + return false + } + return !r.IsValid() +} + +// HasWarnings returns true when this result contains warnings. +// +// Returns false on a nil *Result. +func (r *Result) HasWarnings() bool { + if r == nil { + return false + } + return len(r.Warnings) > 0 +} + +// HasErrorsOrWarnings returns true when this result contains +// either errors or warnings. +// +// Returns false on a nil *Result. +func (r *Result) HasErrorsOrWarnings() bool { + if r == nil { + return false + } + return len(r.Errors) > 0 || len(r.Warnings) > 0 +} + +// Inc increments the match count +func (r *Result) Inc() { + r.MatchCount++ +} + +// AsError renders this result as an error interface +// +// TODO: reporting / pretty print with path ordered and indented +func (r *Result) AsError() error { + if r.IsValid() { + return nil + } + return errors.CompositeValidationError(r.Errors...) +} + func (r *Result) resetCaches() { r.cachedFieldSchemata = nil r.cachedItemSchemata = nil @@ -185,7 +317,7 @@ func (r *Result) resetCaches() { // mergeForField merges other into r, assigning other's root schemata to the given Object and field name. // //nolint:unparam -func (r *Result) mergeForField(obj map[string]interface{}, field string, other *Result) *Result { +func (r *Result) mergeForField(obj map[string]any, field string, other *Result) *Result { if other == nil { return r } @@ -248,7 +380,7 @@ func (r *Result) addRootObjectSchemata(s *spec.Schema) { // addPropertySchemata adds the given schemata for the object and field. // // Since the slice schemata might be reused, it is shallow-cloned before saving it into the result. -func (r *Result) addPropertySchemata(obj map[string]interface{}, fld string, schema *spec.Schema) { +func (r *Result) addPropertySchemata(obj map[string]any, fld string, schema *spec.Schema) { if r.fieldSchemata == nil { r.fieldSchemata = make([]fieldSchemata, 0, len(obj)) } @@ -295,80 +427,12 @@ func (r *Result) mergeWithoutRootSchemata(other *Result) { } } -// MergeAsErrors merges this result with the other one(s), preserving match counts etc. -// -// Warnings from input are merged as Errors in the returned merged Result. -func (r *Result) MergeAsErrors(others ...*Result) *Result { - for _, other := range others { - if other != nil { - r.resetCaches() - r.AddErrors(other.Errors...) - r.AddErrors(other.Warnings...) - r.MatchCount += other.MatchCount - if other.wantsRedeemOnMerge { - pools.poolOfResults.RedeemResult(other) - } - } - } - return r +func isImportant(err error) bool { + return strings.HasPrefix(err.Error(), "IMPORTANT!") } -// MergeAsWarnings merges this result with the other one(s), preserving match counts etc. -// -// Errors from input are merged as Warnings in the returned merged Result. -func (r *Result) MergeAsWarnings(others ...*Result) *Result { - for _, other := range others { - if other != nil { - r.resetCaches() - r.AddWarnings(other.Errors...) - r.AddWarnings(other.Warnings...) - r.MatchCount += other.MatchCount - if other.wantsRedeemOnMerge { - pools.poolOfResults.RedeemResult(other) - } - } - } - return r -} - -// AddErrors adds errors to this validation result (if not already reported). -// -// Since the same check may be passed several times while exploring the -// spec structure (via $ref, ...) reported messages are kept -// unique. -func (r *Result) AddErrors(errors ...error) { - for _, e := range errors { - found := false - if e != nil { - for _, isReported := range r.Errors { - if e.Error() == isReported.Error() { - found = true - break - } - } - if !found { - r.Errors = append(r.Errors, e) - } - } - } -} - -// AddWarnings adds warnings to this validation result (if not already reported). -func (r *Result) AddWarnings(warnings ...error) { - for _, e := range warnings { - found := false - if e != nil { - for _, isReported := range r.Warnings { - if e.Error() == isReported.Error() { - found = true - break - } - } - if !found { - r.Warnings = append(r.Warnings, e) - } - } - } +func stripImportantTag(err error) error { + return stderrors.New(strings.TrimPrefix(err.Error(), "IMPORTANT!")) //nolint:err113 } func (r *Result) keepRelevantErrors() *Result { @@ -386,14 +450,14 @@ func (r *Result) keepRelevantErrors() *Result { // placeholders. strippedErrors := []error{} for _, e := range r.Errors { - if strings.HasPrefix(e.Error(), "IMPORTANT!") { - strippedErrors = append(strippedErrors, stderrors.New(strings.TrimPrefix(e.Error(), "IMPORTANT!"))) + if isImportant(e) { + strippedErrors = append(strippedErrors, stripImportantTag(e)) } } strippedWarnings := []error{} for _, e := range r.Warnings { - if strings.HasPrefix(e.Error(), "IMPORTANT!") { - strippedWarnings = append(strippedWarnings, stderrors.New(strings.TrimPrefix(e.Error(), "IMPORTANT!"))) + if isImportant(e) { + strippedWarnings = append(strippedWarnings, stripImportantTag(e)) } } var strippedResult *Result @@ -407,62 +471,6 @@ func (r *Result) keepRelevantErrors() *Result { return strippedResult } -// IsValid returns true when this result is valid. -// -// Returns true on a nil *Result. -func (r *Result) IsValid() bool { - if r == nil { - return true - } - return len(r.Errors) == 0 -} - -// HasErrors returns true when this result is invalid. -// -// Returns false on a nil *Result. -func (r *Result) HasErrors() bool { - if r == nil { - return false - } - return !r.IsValid() -} - -// HasWarnings returns true when this result contains warnings. -// -// Returns false on a nil *Result. -func (r *Result) HasWarnings() bool { - if r == nil { - return false - } - return len(r.Warnings) > 0 -} - -// HasErrorsOrWarnings returns true when this result contains -// either errors or warnings. -// -// Returns false on a nil *Result. -func (r *Result) HasErrorsOrWarnings() bool { - if r == nil { - return false - } - return len(r.Errors) > 0 || len(r.Warnings) > 0 -} - -// Inc increments the match count -func (r *Result) Inc() { - r.MatchCount++ -} - -// AsError renders this result as an error interface -// -// TODO: reporting / pretty print with path ordered and indented -func (r *Result) AsError() error { - if r.IsValid() { - return nil - } - return errors.CompositeValidationError(r.Errors...) -} - func (r *Result) cleared() *Result { // clear the Result to be reusable. Keep allocated capacity. r.Errors = r.Errors[:0] @@ -510,7 +518,7 @@ func (s *schemata) Slice() []*spec.Schema { return s.multiple } -// appendSchemata appends the schemata in other to s. It mutates s in-place. +// Append appends the schemata in other to s. It mutates s in-place. func (s *schemata) Append(other schemata) { if other.one == nil && len(other.multiple) == 0 { return @@ -552,7 +560,7 @@ func (s schemata) Clone() schemata { if len(s.multiple) > 0 { clone.multiple = make([]*spec.Schema, len(s.multiple)) - for idx := 0; idx < len(s.multiple); idx++ { + for idx := range len(s.multiple) { sp := new(spec.Schema) *sp = *s.multiple[idx] clone.multiple[idx] = sp diff --git a/vendor/github.com/go-openapi/validate/schema.go b/vendor/github.com/go-openapi/validate/schema.go index db65264..8c48899 100644 --- a/vendor/github.com/go-openapi/validate/schema.go +++ b/vendor/github.com/go-openapi/validate/schema.go @@ -21,7 +21,7 @@ import ( "github.com/go-openapi/errors" "github.com/go-openapi/spec" "github.com/go-openapi/strfmt" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // SchemaValidator validates data against a JSON schema @@ -176,12 +176,20 @@ func (s *SchemaValidator) Validate(data interface{}) *Result { // this means that all strfmt types passed here (e.g. strfmt.Datetime, etc..) // are converted here to strings, and structs are systematically converted // to map[string]interface{}. - d = swag.ToDynamicJSON(data) + var dd any + if err := jsonutils.FromDynamicJSON(data, &dd); err != nil { + result.AddErrors(err) + result.Inc() + + return result + } + + d = dd } // TODO: this part should be handed over to type validator // Handle special case of json.Number data (number marshalled as string) - isnumber := s.Schema.Type.Contains(numberType) || s.Schema.Type.Contains(integerType) + isnumber := s.Schema != nil && (s.Schema.Type.Contains(numberType) || s.Schema.Type.Contains(integerType)) if num, ok := data.(json.Number); ok && isnumber { if s.Schema.Type.Contains(integerType) { // avoid lossy conversion in, erri := num.Int64() diff --git a/vendor/github.com/go-openapi/validate/schema_props.go b/vendor/github.com/go-openapi/validate/schema_props.go index 1ca3792..b8bdee8 100644 --- a/vendor/github.com/go-openapi/validate/schema_props.go +++ b/vendor/github.com/go-openapi/validate/schema_props.go @@ -139,7 +139,7 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result { s.validateNot(data, mainResult) } - if s.Dependencies != nil && len(s.Dependencies) > 0 && reflect.TypeOf(data).Kind() == reflect.Map { + if len(s.Dependencies) > 0 && reflect.TypeOf(data).Kind() == reflect.Map { s.validateDependencies(data, mainResult) } diff --git a/vendor/github.com/go-openapi/validate/slice_validator.go b/vendor/github.com/go-openapi/validate/slice_validator.go index 13bb020..7b0dede 100644 --- a/vendor/github.com/go-openapi/validate/slice_validator.go +++ b/vendor/github.com/go-openapi/validate/slice_validator.go @@ -94,7 +94,7 @@ func (s *schemaSliceValidator) Validate(data interface{}) *Result { size := val.Len() if s.Items != nil && s.Items.Schema != nil { - for i := 0; i < size; i++ { + for i := range size { validator := newSchemaValidator(s.Items.Schema, s.Root, s.Path, s.KnownFormats, s.Options) validator.SetPath(fmt.Sprintf("%s.%d", s.Path, i)) value := val.Index(i) @@ -105,7 +105,7 @@ func (s *schemaSliceValidator) Validate(data interface{}) *Result { itemsSize := 0 if s.Items != nil && len(s.Items.Schemas) > 0 { itemsSize = len(s.Items.Schemas) - for i := 0; i < itemsSize; i++ { + for i := range itemsSize { if size <= i { break } diff --git a/vendor/github.com/go-openapi/validate/spec.go b/vendor/github.com/go-openapi/validate/spec.go index 9654525..aef0cc3 100644 --- a/vendor/github.com/go-openapi/validate/spec.go +++ b/vendor/github.com/go-openapi/validate/spec.go @@ -28,7 +28,7 @@ import ( "github.com/go-openapi/loads" "github.com/go-openapi/spec" "github.com/go-openapi/strfmt" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/jsonutils" ) // Spec validates an OpenAPI 2.0 specification document. @@ -85,7 +85,7 @@ func NewSpecValidator(schema *spec.Schema, formats strfmt.Registry) *SpecValidat } // Validate validates the swagger spec -func (s *SpecValidator) Validate(data interface{}) (*Result, *Result) { +func (s *SpecValidator) Validate(data any) (*Result, *Result) { s.schemaOptions.skipSchemataResult = s.Options.SkipSchemataResult var sd *loads.Document errs, warnings := new(Result), new(Result) @@ -101,7 +101,7 @@ func (s *SpecValidator) Validate(data interface{}) (*Result, *Result) { s.analyzer = analysis.New(sd.Spec()) // Raw spec unmarshalling errors - var obj interface{} + var obj any if err := json.Unmarshal(sd.Raw(), &obj); err != nil { // NOTE: under normal conditions, the *load.Document has been already unmarshalled // So this one is just a paranoid check on the behavior of the spec package @@ -161,6 +161,11 @@ func (s *SpecValidator) Validate(data interface{}) (*Result, *Result) { return errs, warnings } +// SetContinueOnErrors sets the ContinueOnErrors option for this validator. +func (s *SpecValidator) SetContinueOnErrors(c bool) { + s.Options.ContinueOnErrors = c +} + func (s *SpecValidator) validateNonEmptyPathParamNames() *Result { res := pools.poolOfResults.BorrowResult() if s.spec.Spec().Paths == nil { @@ -598,7 +603,7 @@ func (s *SpecValidator) validateRequiredProperties(path, in string, v *spec.Sche } } - if !(propertyMatch || patternMatch) { + if !propertyMatch && !patternMatch { if v.AdditionalProperties != nil { if v.AdditionalProperties.Allows && v.AdditionalProperties.Schema == nil { additionalPropertiesMatch = true @@ -618,7 +623,7 @@ func (s *SpecValidator) validateRequiredProperties(path, in string, v *spec.Sche } } - if !(propertyMatch || patternMatch || additionalPropertiesMatch) { + if !propertyMatch && !patternMatch && !additionalPropertiesMatch { res.AddErrors(requiredButNotDefinedMsg(path, in)) } @@ -685,13 +690,19 @@ func (s *SpecValidator) validateParameters() *Result { // clone it once to avoid expanding a global schema (e.g. swagger spec) paramSchema, err := deepCloneSchema(origSchema) if err != nil { - panic(fmt.Errorf("can't clone schema: %v", err)) + panic(fmt.Errorf("can't clone schema: %w", err)) } for _, pr := range paramHelp.safeExpandedParamsFor(path, method, op.ID, res, s) { // An expanded parameter must validate the Parameter schema (an unexpanded $ref always passes high-level schema validation) schv := newSchemaValidator(¶mSchema, s.schema, fmt.Sprintf("%s.%s.parameters.%s", path, method, pr.Name), s.KnownFormats, s.schemaOptions) - obj := swag.ToDynamicJSON(pr) + var obj any + if err := jsonutils.FromDynamicJSON(pr, &obj); err != nil { + res.AddErrors(err) + + return res + } + res.Merge(schv.Validate(obj)) // Validate pattern regexp for parameters with a Pattern property @@ -717,19 +728,19 @@ func (s *SpecValidator) validateParameters() *Result { hasForm = true } - if !(pr.Type == numberType || pr.Type == integerType) && + if pr.Type != numberType && pr.Type != integerType && (pr.Maximum != nil || pr.Minimum != nil || pr.MultipleOf != nil) { // A non-numeric parameter has validation keywords for numeric instances (number and integer) res.AddWarnings(parameterValidationTypeMismatchMsg(pr.Name, path, pr.Type)) } - if !(pr.Type == stringType) && + if pr.Type != stringType && // A non-string parameter has validation keywords for strings (pr.MaxLength != nil || pr.MinLength != nil || pr.Pattern != "") { res.AddWarnings(parameterValidationTypeMismatchMsg(pr.Name, path, pr.Type)) } - if !(pr.Type == arrayType) && + if pr.Type != arrayType && // A non-array parameter has validation keywords for arrays (pr.MaxItems != nil || pr.MinItems != nil || pr.UniqueItems) { res.AddWarnings(parameterValidationTypeMismatchMsg(pr.Name, path, pr.Type)) @@ -823,11 +834,6 @@ func (s *SpecValidator) checkUniqueParams(path, method string, op *spec.Operatio return res } -// SetContinueOnErrors sets the ContinueOnErrors option for this validator. -func (s *SpecValidator) SetContinueOnErrors(c bool) { - s.Options.ContinueOnErrors = c -} - // expandedAnalyzer returns expanded.Analyzer when it is available. // otherwise just analyzer. func (s *SpecValidator) expandedAnalyzer() *analysis.Spec { diff --git a/vendor/github.com/go-openapi/validate/spec_messages.go b/vendor/github.com/go-openapi/validate/spec_messages.go index 6d1f0f8..8da22cf 100644 --- a/vendor/github.com/go-openapi/validate/spec_messages.go +++ b/vendor/github.com/go-openapi/validate/spec_messages.go @@ -34,7 +34,7 @@ const ( // BothFormDataAndBodyError indicates that an operation specifies both a body and a formData parameter, which is forbidden BothFormDataAndBodyError = "operation %q has both formData and body parameters. Only one such In: type may be used for a given operation" - // CannotResolveRefError when a $ref could not be resolved + // CannotResolveReferenceError when a $ref could not be resolved CannotResolveReferenceError = "could not resolve reference in %s to $ref %s: %v" // CircularAncestryDefinitionError ... @@ -135,7 +135,7 @@ const ( // PathParamNotUniqueError ... PathParamNotUniqueError = "params in path %q must be unique: %q conflicts with %q" - // PathParamNotRequiredError ... + // PathParamRequiredError ... PathParamRequiredError = "in operation %q,path param %q must be declared as required" // RefNotAllowedInHeaderError indicates a $ref was found in a header definition, which is not allowed by Swagger diff --git a/vendor/github.com/go-openapi/validate/type.go b/vendor/github.com/go-openapi/validate/type.go index f87abb3..91ae341 100644 --- a/vendor/github.com/go-openapi/validate/type.go +++ b/vendor/github.com/go-openapi/validate/type.go @@ -21,7 +21,8 @@ import ( "github.com/go-openapi/errors" "github.com/go-openapi/spec" "github.com/go-openapi/strfmt" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/conv" + "github.com/go-openapi/swag/fileutils" ) type typeValidator struct { @@ -55,6 +56,70 @@ func newTypeValidator(path, in string, typ spec.StringOrArray, nullable bool, fo return t } +func (t *typeValidator) SetPath(path string) { + t.Path = path +} + +func (t *typeValidator) Applies(source interface{}, _ reflect.Kind) bool { + // typeValidator applies to Schema, Parameter and Header objects + switch source.(type) { + case *spec.Schema: + case *spec.Parameter: + case *spec.Header: + default: + return false + } + + return (len(t.Type) > 0 || t.Format != "") +} + +func (t *typeValidator) Validate(data interface{}) *Result { + if t.Options.recycleValidators { + defer func() { + t.redeem() + }() + } + + if data == nil { + // nil or zero value for the passed structure require Type: null + if len(t.Type) > 0 && !t.Type.Contains(nullType) && !t.Nullable { // TODO: if a property is not required it also passes this + return errorHelp.sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), nullType), t.Options.recycleResult) + } + + return emptyResult + } + + // check if the type matches, should be used in every validator chain as first item + val := reflect.Indirect(reflect.ValueOf(data)) + kind := val.Kind() + + // infer schema type (JSON) and format from passed data type + schType, format := t.schemaInfoForType(data) + + // check numerical types + // TODO: check unsigned ints + // TODO: check json.Number (see schema.go) + isLowerInt := t.Format == integerFormatInt64 && format == integerFormatInt32 + isLowerFloat := t.Format == numberFormatFloat64 && format == numberFormatFloat32 + isFloatInt := schType == numberType && conv.IsFloat64AJSONInteger(val.Float()) && t.Type.Contains(integerType) + isIntFloat := schType == integerType && t.Type.Contains(numberType) + + if kind != reflect.String && kind != reflect.Slice && t.Format != "" && !t.Type.Contains(schType) && format != t.Format && !isFloatInt && !isIntFloat && !isLowerInt && !isLowerFloat { + // TODO: test case + return errorHelp.sErr(errors.InvalidType(t.Path, t.In, t.Format, format), t.Options.recycleResult) + } + + if !t.Type.Contains(numberType) && !t.Type.Contains(integerType) && t.Format != "" && (kind == reflect.String || kind == reflect.Slice) { + return emptyResult + } + + if !t.Type.Contains(schType) && !isFloatInt && !isIntFloat { + return errorHelp.sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), schType), t.Options.recycleResult) + } + + return emptyResult +} + func (t *typeValidator) schemaInfoForType(data interface{}) (string, string) { // internal type to JSON type with swagger 2.0 format (with go-openapi/strfmt extensions), // see https://github.com/go-openapi/strfmt/blob/master/README.md @@ -70,7 +135,7 @@ func (t *typeValidator) schemaInfoForType(data interface{}) (string, string) { return stringType, stringFormatDateTime case strfmt.Duration, *strfmt.Duration: return stringType, stringFormatDuration - case swag.File, *swag.File: + case fileutils.File, *fileutils.File: return fileType, "" case strfmt.Email, *strfmt.Email: return stringType, stringFormatEmail @@ -144,70 +209,6 @@ func (t *typeValidator) schemaInfoForType(data interface{}) (string, string) { return "", "" } -func (t *typeValidator) SetPath(path string) { - t.Path = path -} - -func (t *typeValidator) Applies(source interface{}, _ reflect.Kind) bool { - // typeValidator applies to Schema, Parameter and Header objects - switch source.(type) { - case *spec.Schema: - case *spec.Parameter: - case *spec.Header: - default: - return false - } - - return (len(t.Type) > 0 || t.Format != "") -} - -func (t *typeValidator) Validate(data interface{}) *Result { - if t.Options.recycleValidators { - defer func() { - t.redeem() - }() - } - - if data == nil { - // nil or zero value for the passed structure require Type: null - if len(t.Type) > 0 && !t.Type.Contains(nullType) && !t.Nullable { // TODO: if a property is not required it also passes this - return errorHelp.sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), nullType), t.Options.recycleResult) - } - - return emptyResult - } - - // check if the type matches, should be used in every validator chain as first item - val := reflect.Indirect(reflect.ValueOf(data)) - kind := val.Kind() - - // infer schema type (JSON) and format from passed data type - schType, format := t.schemaInfoForType(data) - - // check numerical types - // TODO: check unsigned ints - // TODO: check json.Number (see schema.go) - isLowerInt := t.Format == integerFormatInt64 && format == integerFormatInt32 - isLowerFloat := t.Format == numberFormatFloat64 && format == numberFormatFloat32 - isFloatInt := schType == numberType && swag.IsFloat64AJSONInteger(val.Float()) && t.Type.Contains(integerType) - isIntFloat := schType == integerType && t.Type.Contains(numberType) - - if kind != reflect.String && kind != reflect.Slice && t.Format != "" && !(t.Type.Contains(schType) || format == t.Format || isFloatInt || isIntFloat || isLowerInt || isLowerFloat) { - // TODO: test case - return errorHelp.sErr(errors.InvalidType(t.Path, t.In, t.Format, format), t.Options.recycleResult) - } - - if !(t.Type.Contains(numberType) || t.Type.Contains(integerType)) && t.Format != "" && (kind == reflect.String || kind == reflect.Slice) { - return emptyResult - } - - if !(t.Type.Contains(schType) || isFloatInt || isIntFloat) { - return errorHelp.sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), schType), t.Options.recycleResult) - } - - return emptyResult -} - func (t *typeValidator) redeem() { pools.poolOfTypeValidators.RedeemValidator(t) } diff --git a/vendor/github.com/go-openapi/validate/validator.go b/vendor/github.com/go-openapi/validate/validator.go index c083aec..b76b863 100644 --- a/vendor/github.com/go-openapi/validate/validator.go +++ b/vendor/github.com/go-openapi/validate/validator.go @@ -769,7 +769,7 @@ func (s *basicSliceValidator) Validate(data interface{}) *Result { return nil } - for i := 0; i < int(size); i++ { + for i := range int(size) { itemsValidator := newItemsValidator(s.Path, s.In, s.Items, s.Source, s.KnownFormats, s.Options) ele := val.Index(i) if err := itemsValidator.Validate(i, ele.Interface()); err != nil { diff --git a/vendor/github.com/go-openapi/validate/values.go b/vendor/github.com/go-openapi/validate/values.go index 5f6f5ee..1bfa6f3 100644 --- a/vendor/github.com/go-openapi/validate/values.go +++ b/vendor/github.com/go-openapi/validate/values.go @@ -23,24 +23,33 @@ import ( "github.com/go-openapi/errors" "github.com/go-openapi/strfmt" - "github.com/go-openapi/swag" + "github.com/go-openapi/swag/conv" ) +type valueError string + +func (e valueError) Error() string { + return string(e) +} + +// ErrValue indicates that a value validation occurred +const ErrValue valueError = "value validation error" + // Enum validates if the data is a member of the enum -func Enum(path, in string, data interface{}, enum interface{}) *errors.Validation { +func Enum(path, in string, data any, enum any) *errors.Validation { return EnumCase(path, in, data, enum, true) } // EnumCase validates if the data is a member of the enum and may respect case-sensitivity for strings -func EnumCase(path, in string, data interface{}, enum interface{}, caseSensitive bool) *errors.Validation { +func EnumCase(path, in string, data any, enum any, caseSensitive bool) *errors.Validation { val := reflect.ValueOf(enum) if val.Kind() != reflect.Slice { return nil } dataString := convertEnumCaseStringKind(data, caseSensitive) - var values []interface{} - for i := 0; i < val.Len(); i++ { + values := make([]any, 0, val.Len()) + for i := range val.Len() { ele := val.Index(i) enumValue := ele.Interface() if data != nil { @@ -69,7 +78,7 @@ func EnumCase(path, in string, data interface{}, enum interface{}, caseSensitive } // convertEnumCaseStringKind converts interface if it is kind of string and case insensitivity is set -func convertEnumCaseStringKind(value interface{}, caseSensitive bool) *string { +func convertEnumCaseStringKind(value any, caseSensitive bool) *string { if caseSensitive { return nil } @@ -84,29 +93,29 @@ func convertEnumCaseStringKind(value interface{}, caseSensitive bool) *string { } // MinItems validates that there are at least n items in a slice -func MinItems(path, in string, size, min int64) *errors.Validation { - if size < min { - return errors.TooFewItems(path, in, min, size) +func MinItems(path, in string, size, minimum int64) *errors.Validation { + if size < minimum { + return errors.TooFewItems(path, in, minimum, size) } return nil } // MaxItems validates that there are at most n items in a slice -func MaxItems(path, in string, size, max int64) *errors.Validation { - if size > max { - return errors.TooManyItems(path, in, max, size) +func MaxItems(path, in string, size, maximum int64) *errors.Validation { + if size > maximum { + return errors.TooManyItems(path, in, maximum, size) } return nil } // UniqueItems validates that the provided slice has unique elements -func UniqueItems(path, in string, data interface{}) *errors.Validation { +func UniqueItems(path, in string, data any) *errors.Validation { val := reflect.ValueOf(data) if val.Kind() != reflect.Slice { return nil } - var unique []interface{} - for i := 0; i < val.Len(); i++ { + unique := make([]any, 0, val.Len()) + for i := range val.Len() { v := val.Index(i).Interface() for _, u := range unique { if reflect.DeepEqual(v, u) { @@ -137,7 +146,7 @@ func MaxLength(path, in, data string, maxLength int64) *errors.Validation { } // ReadOnly validates an interface for readonly -func ReadOnly(ctx context.Context, path, in string, data interface{}) *errors.Validation { +func ReadOnly(ctx context.Context, path, in string, data any) *errors.Validation { // read only is only validated when operationType is request if op := extractOperationType(ctx); op != request { @@ -158,7 +167,7 @@ func ReadOnly(ctx context.Context, path, in string, data interface{}) *errors.Va } // Required validates an interface for requiredness -func Required(path, in string, data interface{}) *errors.Validation { +func Required(path, in string, data any) *errors.Validation { val := reflect.ValueOf(data) if val.IsValid() { if reflect.DeepEqual(reflect.Zero(val.Type()).Interface(), val.Interface()) { @@ -198,49 +207,49 @@ func Pattern(path, in, data, pattern string) *errors.Validation { } // MaximumInt validates if a number is smaller than a given maximum -func MaximumInt(path, in string, data, max int64, exclusive bool) *errors.Validation { - if (!exclusive && data > max) || (exclusive && data >= max) { - return errors.ExceedsMaximumInt(path, in, max, exclusive, data) +func MaximumInt(path, in string, data, maximum int64, exclusive bool) *errors.Validation { + if (!exclusive && data > maximum) || (exclusive && data >= maximum) { + return errors.ExceedsMaximumInt(path, in, maximum, exclusive, data) } return nil } // MaximumUint validates if a number is smaller than a given maximum -func MaximumUint(path, in string, data, max uint64, exclusive bool) *errors.Validation { - if (!exclusive && data > max) || (exclusive && data >= max) { - return errors.ExceedsMaximumUint(path, in, max, exclusive, data) +func MaximumUint(path, in string, data, maximum uint64, exclusive bool) *errors.Validation { + if (!exclusive && data > maximum) || (exclusive && data >= maximum) { + return errors.ExceedsMaximumUint(path, in, maximum, exclusive, data) } return nil } // Maximum validates if a number is smaller than a given maximum -func Maximum(path, in string, data, max float64, exclusive bool) *errors.Validation { - if (!exclusive && data > max) || (exclusive && data >= max) { - return errors.ExceedsMaximum(path, in, max, exclusive, data) +func Maximum(path, in string, data, maximum float64, exclusive bool) *errors.Validation { + if (!exclusive && data > maximum) || (exclusive && data >= maximum) { + return errors.ExceedsMaximum(path, in, maximum, exclusive, data) } return nil } // Minimum validates if a number is smaller than a given minimum -func Minimum(path, in string, data, min float64, exclusive bool) *errors.Validation { - if (!exclusive && data < min) || (exclusive && data <= min) { - return errors.ExceedsMinimum(path, in, min, exclusive, data) +func Minimum(path, in string, data, minimum float64, exclusive bool) *errors.Validation { + if (!exclusive && data < minimum) || (exclusive && data <= minimum) { + return errors.ExceedsMinimum(path, in, minimum, exclusive, data) } return nil } // MinimumInt validates if a number is smaller than a given minimum -func MinimumInt(path, in string, data, min int64, exclusive bool) *errors.Validation { - if (!exclusive && data < min) || (exclusive && data <= min) { - return errors.ExceedsMinimumInt(path, in, min, exclusive, data) +func MinimumInt(path, in string, data, minimum int64, exclusive bool) *errors.Validation { + if (!exclusive && data < minimum) || (exclusive && data <= minimum) { + return errors.ExceedsMinimumInt(path, in, minimum, exclusive, data) } return nil } // MinimumUint validates if a number is smaller than a given minimum -func MinimumUint(path, in string, data, min uint64, exclusive bool) *errors.Validation { - if (!exclusive && data < min) || (exclusive && data <= min) { - return errors.ExceedsMinimumUint(path, in, min, exclusive, data) +func MinimumUint(path, in string, data, minimum uint64, exclusive bool) *errors.Validation { + if (!exclusive && data < minimum) || (exclusive && data <= minimum) { + return errors.ExceedsMinimumUint(path, in, minimum, exclusive, data) } return nil } @@ -257,7 +266,7 @@ func MultipleOf(path, in string, data, factor float64) *errors.Validation { } else { mult = data / factor } - if !swag.IsFloat64AJSONInteger(mult) { + if !conv.IsFloat64AJSONInteger(mult) { return errors.NotMultipleOf(path, in, factor, data) } return nil @@ -313,23 +322,23 @@ func FormatOf(path, in, format, data string, registry strfmt.Registry) *errors.V // which means there may be a loss during conversions (e.g. for very large integers) // // TODO: Normally, a JSON MAX_SAFE_INTEGER check would ensure conversion remains loss-free -func MaximumNativeType(path, in string, val interface{}, max float64, exclusive bool) *errors.Validation { +func MaximumNativeType(path, in string, val any, maximum float64, exclusive bool) *errors.Validation { kind := reflect.ValueOf(val).Type().Kind() switch kind { //nolint:exhaustive case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: value := valueHelp.asInt64(val) - return MaximumInt(path, in, value, int64(max), exclusive) + return MaximumInt(path, in, value, int64(maximum), exclusive) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: value := valueHelp.asUint64(val) - if max < 0 { - return errors.ExceedsMaximum(path, in, max, exclusive, val) + if maximum < 0 { + return errors.ExceedsMaximum(path, in, maximum, exclusive, val) } - return MaximumUint(path, in, value, uint64(max), exclusive) + return MaximumUint(path, in, value, uint64(maximum), exclusive) case reflect.Float32, reflect.Float64: fallthrough default: value := valueHelp.asFloat64(val) - return Maximum(path, in, value, max, exclusive) + return Maximum(path, in, value, maximum, exclusive) } } @@ -343,23 +352,23 @@ func MaximumNativeType(path, in string, val interface{}, max float64, exclusive // which means there may be a loss during conversions (e.g. for very large integers) // // TODO: Normally, a JSON MAX_SAFE_INTEGER check would ensure conversion remains loss-free -func MinimumNativeType(path, in string, val interface{}, min float64, exclusive bool) *errors.Validation { +func MinimumNativeType(path, in string, val any, minimum float64, exclusive bool) *errors.Validation { kind := reflect.ValueOf(val).Type().Kind() switch kind { //nolint:exhaustive case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: value := valueHelp.asInt64(val) - return MinimumInt(path, in, value, int64(min), exclusive) + return MinimumInt(path, in, value, int64(minimum), exclusive) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: value := valueHelp.asUint64(val) - if min < 0 { + if minimum < 0 { return nil } - return MinimumUint(path, in, value, uint64(min), exclusive) + return MinimumUint(path, in, value, uint64(minimum), exclusive) case reflect.Float32, reflect.Float64: fallthrough default: value := valueHelp.asFloat64(val) - return Minimum(path, in, value, min, exclusive) + return Minimum(path, in, value, minimum, exclusive) } } @@ -373,7 +382,7 @@ func MinimumNativeType(path, in string, val interface{}, min float64, exclusive // which means there may be a loss during conversions (e.g. for very large integers) // // TODO: Normally, a JSON MAX_SAFE_INTEGER check would ensure conversion remains loss-free -func MultipleOfNativeType(path, in string, val interface{}, multipleOf float64) *errors.Validation { +func MultipleOfNativeType(path, in string, val any, multipleOf float64) *errors.Validation { kind := reflect.ValueOf(val).Type().Kind() switch kind { //nolint:exhaustive case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: @@ -394,20 +403,20 @@ func MultipleOfNativeType(path, in string, val interface{}, multipleOf float64) // the range defined by Type and Format, that is, may be converted without loss. // // NOTE: this check is about type capacity and not formal verification such as: 1.0 != 1L -func IsValueValidAgainstRange(val interface{}, typeName, format, prefix, path string) error { +func IsValueValidAgainstRange(val any, typeName, format, prefix, path string) error { kind := reflect.ValueOf(val).Type().Kind() // What is the string representation of val var stringRep string switch kind { //nolint:exhaustive case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - stringRep = swag.FormatUint64(valueHelp.asUint64(val)) + stringRep = conv.FormatUinteger(valueHelp.asUint64(val)) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - stringRep = swag.FormatInt64(valueHelp.asInt64(val)) + stringRep = conv.FormatInteger(valueHelp.asInt64(val)) case reflect.Float32, reflect.Float64: - stringRep = swag.FormatFloat64(valueHelp.asFloat64(val)) + stringRep = conv.FormatFloat(valueHelp.asFloat64(val)) default: - return fmt.Errorf("%s value number range checking called with invalid (non numeric) val type in %s", prefix, path) + return fmt.Errorf("%s value number range checking called with invalid (non numeric) val type in %s: %w", prefix, path, ErrValue) } var errVal error @@ -416,22 +425,22 @@ func IsValueValidAgainstRange(val interface{}, typeName, format, prefix, path st case integerType: switch format { case integerFormatInt32: - _, errVal = swag.ConvertInt32(stringRep) + _, errVal = conv.ConvertInt32(stringRep) case integerFormatUInt32: - _, errVal = swag.ConvertUint32(stringRep) + _, errVal = conv.ConvertUint32(stringRep) case integerFormatUInt64: - _, errVal = swag.ConvertUint64(stringRep) + _, errVal = conv.ConvertUint64(stringRep) case integerFormatInt64: fallthrough default: - _, errVal = swag.ConvertInt64(stringRep) + _, errVal = conv.ConvertInt64(stringRep) } case numberType: fallthrough default: switch format { case numberFormatFloat, numberFormatFloat32: - _, errVal = swag.ConvertFloat32(stringRep) + _, errVal = conv.ConvertFloat32(stringRep) case numberFormatDouble, numberFormatFloat64: fallthrough default: @@ -441,9 +450,9 @@ func IsValueValidAgainstRange(val interface{}, typeName, format, prefix, path st } if errVal != nil { // We don't report the actual errVal from strconv if format != "" { - errVal = fmt.Errorf("%s value must be of type %s with format %s in %s", prefix, typeName, format, path) + errVal = fmt.Errorf("%s value must be of type %s with format %s in %s: %w", prefix, typeName, format, path, ErrValue) } else { - errVal = fmt.Errorf("%s value must be of type %s (default format) in %s", prefix, typeName, path) + errVal = fmt.Errorf("%s value must be of type %s (default format) in %s: %w", prefix, typeName, path, ErrValue) } } return errVal diff --git a/vendor/modules.txt b/vendor/modules.txt index 8082b4a..f3746db 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -11,8 +11,8 @@ github.com/go-logr/logr/funcr # github.com/go-logr/stdr v1.2.2 ## explicit; go 1.16 github.com/go-logr/stdr -# github.com/go-openapi/analysis v0.23.0 -## explicit; go 1.20 +# github.com/go-openapi/analysis v0.24.0 +## explicit; go 1.24.0 github.com/go-openapi/analysis github.com/go-openapi/analysis/internal/debug github.com/go-openapi/analysis/internal/flatten/normalize @@ -23,15 +23,15 @@ github.com/go-openapi/analysis/internal/flatten/sortref # github.com/go-openapi/errors v0.22.3 ## explicit; go 1.24.0 github.com/go-openapi/errors -# github.com/go-openapi/jsonpointer v0.21.0 -## explicit; go 1.20 +# github.com/go-openapi/jsonpointer v0.22.1 +## explicit; go 1.24.0 github.com/go-openapi/jsonpointer -# github.com/go-openapi/jsonreference v0.21.0 -## explicit; go 1.20 +# github.com/go-openapi/jsonreference v0.21.2 +## explicit; go 1.24.0 github.com/go-openapi/jsonreference github.com/go-openapi/jsonreference/internal -# github.com/go-openapi/loads v0.22.0 -## explicit; go 1.20 +# github.com/go-openapi/loads v0.23.1 +## explicit; go 1.24.0 github.com/go-openapi/loads # github.com/go-openapi/runtime v0.28.0 ## explicit; go 1.20 @@ -44,8 +44,8 @@ github.com/go-openapi/runtime/middleware/header github.com/go-openapi/runtime/middleware/untyped github.com/go-openapi/runtime/security github.com/go-openapi/runtime/yamlpc -# github.com/go-openapi/spec v0.21.0 -## explicit; go 1.20 +# github.com/go-openapi/spec v0.22.0 +## explicit; go 1.24.0 github.com/go-openapi/spec # github.com/go-openapi/strfmt v0.24.0 ## explicit; go 1.24.0 @@ -89,8 +89,8 @@ github.com/go-openapi/swag/typeutils # github.com/go-openapi/swag/yamlutils v0.25.1 ## explicit; go 1.24.0 github.com/go-openapi/swag/yamlutils -# github.com/go-openapi/validate v0.24.0 -## explicit; go 1.20 +# github.com/go-openapi/validate v0.25.0 +## explicit; go 1.24.0 github.com/go-openapi/validate # github.com/go-viper/mapstructure/v2 v2.4.0 ## explicit; go 1.18