Documentation

Overview

    Copyright 2019 DeepMap, Inc.

    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

    Copyright 2019 DeepMap, Inc.

    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

    Copyright 2019 DeepMap, Inc.

    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

    Copyright 2019 DeepMap, Inc.

    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var TemplateFunctions = template.FuncMap{
    	"genParamArgs":               genParamArgs,
    	"genParamTypes":              genParamTypes,
    	"genParamNames":              genParamNames,
    	"genParamFmtString":          genParamFmtString,
    	"swaggerUriToEchoUri":        SwaggerUriToEchoUri,
    	"swaggerUriToChiUri":         SwaggerUriToChiUri,
    	"lcFirst":                    LowercaseFirstCharacter,
    	"ucFirst":                    UppercaseFirstCharacter,
    	"camelCase":                  ToCamelCase,
    	"genResponsePayload":         genResponsePayload,
    	"genResponseTypeName":        genResponseTypeName,
    	"genResponseUnmarshal":       genResponseUnmarshal,
    	"getResponseTypeDefinitions": getResponseTypeDefinitions,
    	"toStringArray":              toStringArray,
    	"lower":                      strings.ToLower,
    	"title":                      strings.Title,
    	"stripNewLines":              stripNewLines,
    }

      This function map is passed to the template engine, and we can call each function here by keyName from the template code.

      Functions

      func EmbeddedTypeNames

      func EmbeddedTypeNames(allOf []*openapi3.SchemaRef) ([]string, error)

      func GenFieldsFromProperties

      func GenFieldsFromProperties(props []Property) []string

        Given a list of schema descriptors, produce corresponding field names with JSON annotations

        func GenStructFromAllOf

        func GenStructFromAllOf(allOf []*openapi3.SchemaRef, path []string) (string, error)

          This function generates an object that is the union of the objects in the input array. In the case of Ref objects, we use an embedded struct, otherwise, we inline the fields.

          func GenStructFromSchema

          func GenStructFromSchema(schema Schema) string

          func Generate

          func Generate(swagger *openapi3.Swagger, packageName string, opts Options) (string, error)

            Uses the Go templating engine to generate all of our server wrappers from the descriptions we've built up above from the schema objects. opts defines

            func GenerateAdditionalPropertyBoilerplate

            func GenerateAdditionalPropertyBoilerplate(t *template.Template, typeDefs []TypeDefinition) (string, error)

              Generate all the glue code which provides the API for interacting with additional properties and JSON-ification

              func GenerateBodyDefinitions

              func GenerateBodyDefinitions(operationID string, bodyOrRef *openapi3.RequestBodyRef) ([]RequestBodyDefinition, []TypeDefinition, error)

                This function turns the Swagger body definitions into a list of our body definitions which will be used for code generation.

                func GenerateChiServer

                func GenerateChiServer(t *template.Template, operations []OperationDefinition) (string, error)

                  GenerateChiServer This function generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

                  func GenerateClient

                  func GenerateClient(t *template.Template, ops []OperationDefinition) (string, error)

                    Uses the template engine to generate the function which registers our wrappers as Echo path handlers.

                    func GenerateClientWithResponses

                    func GenerateClientWithResponses(t *template.Template, ops []OperationDefinition) (string, error)

                      This generates a client which extends the basic client which does response unmarshaling.

                      func GenerateEchoServer

                      func GenerateEchoServer(t *template.Template, operations []OperationDefinition) (string, error)

                        GenerateEchoServer This function generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

                        func GenerateImports

                        func GenerateImports(t *template.Template, externalImports []string, packageName string) (string, error)

                          Generate our import statements and package definition.

                          func GenerateInlinedSpec

                          func GenerateInlinedSpec(t *template.Template, swagger *openapi3.Swagger) (string, error)

                            This generates a gzipped, base64 encoded JSON representation of the swagger definition, which we embed inside the generated code.

                            func GenerateRegistration

                            func GenerateRegistration(t *template.Template, ops []OperationDefinition) (string, error)

                              Uses the template engine to generate the function which registers our wrappers as Echo path handlers.

                              func GenerateServerInterface

                              func GenerateServerInterface(t *template.Template, ops []OperationDefinition) (string, error)

                                Uses the template engine to generate the server interface

                                func GenerateTypeDefinitions

                                func GenerateTypeDefinitions(t *template.Template, swagger *openapi3.Swagger, ops []OperationDefinition, excludeSchemas []string) (string, error)

                                func GenerateTypes

                                func GenerateTypes(t *template.Template, types []TypeDefinition) (string, error)

                                  Helper function to pass a bunch of types to the template engine, and buffer its output into a string.

                                  func GenerateTypesForOperations

                                  func GenerateTypesForOperations(t *template.Template, ops []OperationDefinition) (string, error)

                                    Generates code for all types produced

                                    func GenerateWrappers

                                    func GenerateWrappers(t *template.Template, ops []OperationDefinition) (string, error)

                                      Uses the template engine to generate all the wrappers which wrap our simple interface functions and perform marshallin/unmarshalling from HTTP request objects.

                                      func IsGoIdentity

                                      func IsGoIdentity(str string) bool

                                        IsGoIdentity checks if the given string can be used as an identity in the generated code like a type name or constant name.

                                        See https://golang.org/ref/spec#Identifiers

                                        func IsGoKeyword

                                        func IsGoKeyword(str string) bool

                                          Returns whether the given string is a go keyword

                                          func IsPredeclaredGoIdentifier

                                          func IsPredeclaredGoIdentifier(str string) bool

                                            IsPredeclaredGoIdentifier returns whether the given string is a predefined go indentifier.

                                            See https://golang.org/ref/spec#Predeclared_identifiers

                                            func IsValidGoIdentity

                                            func IsValidGoIdentity(str string) bool

                                              IsValidGoIdentity checks if the given string can be used as a name of variable, constant, or type.

                                              func LowercaseFirstCharacter

                                              func LowercaseFirstCharacter(str string) string

                                                Same as above, except lower case

                                                func OrderedParamsFromUri

                                                func OrderedParamsFromUri(uri string) []string

                                                  Returns the argument names, in order, in a given URI string, so for /path/{param1}/{.param2*}/{?param3}, it would return param1, param2, param3

                                                  func PathToTypeName

                                                  func PathToTypeName(path []string) string

                                                    This converts a path, like Object/field1/nestedField into a go type name.

                                                    func PropertiesEqual

                                                    func PropertiesEqual(a, b Property) bool

                                                    func RefPathToGoType

                                                    func RefPathToGoType(refPath string) (string, error)

                                                      This function takes a $ref value and converts it to a Go typename. #/components/schemas/Foo -> Foo #/components/parameters/Bar -> Bar #/components/responses/Baz -> Baz Remote components (document.json#/Foo) are supported if they present in --import-mapping URL components (http://deepmap.com/schemas/document.json#Foo) are supported if they present in --import-mapping

                                                      func ReplacePathParamsWithStr

                                                      func ReplacePathParamsWithStr(uri string) string

                                                        Replaces path parameters with %s

                                                        func SanitizeCode

                                                        func SanitizeCode(goCode string) string

                                                          SanitizeCode runs sanitizers across the generated Go code to ensure the generated code will be able to compile.

                                                          func SanitizeEnumNames

                                                          func SanitizeEnumNames(enumNames []string) map[string]string

                                                            SanitizeEnumNames fixes illegal chars in the enum names and removes duplicates

                                                            func SanitizeGoIdentity

                                                            func SanitizeGoIdentity(str string) string

                                                              SanitizeGoIdentity deletes and replaces the illegal runes in the given string to use the string as a valid identity.

                                                              func SchemaHasAdditionalProperties

                                                              func SchemaHasAdditionalProperties(schema *openapi3.Schema) bool

                                                                According to the spec, additionalProperties may be true, false, or a schema. If not present, true is implied. If it's a schema, true is implied. If it's false, no additional properties are allowed. We're going to act a little differently, in that if you want additionalProperties code to be generated, you must specify an additionalProperties type If additionalProperties it true/false, this field will be non-nil.

                                                                func SchemaNameToTypeName

                                                                func SchemaNameToTypeName(name string) string

                                                                  Converts a Schema name to a valid Go type name. It converts to camel case, and makes sure the name is valid in Go

                                                                  func SortedContentKeys

                                                                  func SortedContentKeys(dict openapi3.Content) []string

                                                                    This returns Content dictionary keys in sorted order

                                                                    func SortedOperationsKeys

                                                                    func SortedOperationsKeys(dict map[string]*openapi3.Operation) []string

                                                                      This function returns Operation dictionary keys in sorted order

                                                                      func SortedParameterKeys

                                                                      func SortedParameterKeys(dict map[string]*openapi3.ParameterRef) []string

                                                                        This returns sorted keys for a ParameterRef dict

                                                                        func SortedPathsKeys

                                                                        func SortedPathsKeys(dict openapi3.Paths) []string

                                                                          This function is the same as above, except it sorts the keys for a Paths dictionary.

                                                                          func SortedRequestBodyKeys

                                                                          func SortedRequestBodyKeys(dict map[string]*openapi3.RequestBodyRef) []string

                                                                          func SortedResponsesKeys

                                                                          func SortedResponsesKeys(dict openapi3.Responses) []string

                                                                            This function returns Responses dictionary keys in sorted order

                                                                            func SortedSchemaKeys

                                                                            func SortedSchemaKeys(dict map[string]*openapi3.SchemaRef) []string

                                                                              This function returns the keys of the given SchemaRef dictionary in sorted order, since Golang scrambles dictionary keys

                                                                              func SortedStringKeys

                                                                              func SortedStringKeys(dict map[string]string) []string

                                                                                This returns string map keys in sorted order

                                                                                func StringInArray

                                                                                func StringInArray(str string, array []string) bool

                                                                                  This function checks whether the specified string is present in an array of strings

                                                                                  func StringToGoComment

                                                                                  func StringToGoComment(in string) string

                                                                                    StringToGoComment renders a possible multi-line string as a valid Go-Comment. Each line is prefixed as a comment.

                                                                                    func SwaggerUriToChiUri

                                                                                    func SwaggerUriToChiUri(uri string) string

                                                                                      This function converts a swagger style path URI with parameters to a Chi compatible path URI. We need to replace all of Swagger parameters with "{param}". Valid input parameters are:

                                                                                      {param}
                                                                                      {param*}
                                                                                      {.param}
                                                                                      {.param*}
                                                                                      {;param}
                                                                                      {;param*}
                                                                                      {?param}
                                                                                      {?param*}
                                                                                      

                                                                                      func SwaggerUriToEchoUri

                                                                                      func SwaggerUriToEchoUri(uri string) string

                                                                                        This function converts a swagger style path URI with parameters to a Echo compatible path URI. We need to replace all of Swagger parameters with ":param". Valid input parameters are:

                                                                                        {param}
                                                                                        {param*}
                                                                                        {.param}
                                                                                        {.param*}
                                                                                        {;param}
                                                                                        {;param*}
                                                                                        {?param}
                                                                                        {?param*}
                                                                                        

                                                                                        func ToCamelCase

                                                                                        func ToCamelCase(str string) string

                                                                                          This function will convert query-arg style strings to CamelCase. We will use `., -, +, :, ;, _, ~, ' ', (, ), {, }, [, ]` as valid delimiters for words. So, "word.word-word+word:word;word_word~word word(word)word{word}[word]" would be converted to WordWordWordWordWordWordWordWordWordWordWordWordWord

                                                                                          func UppercaseFirstCharacter

                                                                                          func UppercaseFirstCharacter(str string) string

                                                                                            Uppercase the first character in a string. This assumes UTF-8, so we have to be careful with unicode, don't treat it as a byte array.

                                                                                            Types

                                                                                            type FieldDescriptor

                                                                                            type FieldDescriptor struct {
                                                                                            	Required bool   // Is the schema required? If not, we'll pass by pointer
                                                                                            	GoType   string // The Go type needed to represent the json type.
                                                                                            	GoName   string // The Go compatible type name for the type
                                                                                            	JsonName string // The json type name for the type
                                                                                            	IsRef    bool   // Is this schema a reference to predefined object?
                                                                                            }

                                                                                            type OperationDefinition

                                                                                            type OperationDefinition struct {
                                                                                            	OperationId string // The operation_id description from Swagger, used to generate function names
                                                                                            
                                                                                            	PathParams          []ParameterDefinition // Parameters in the path, eg, /path/:param
                                                                                            	HeaderParams        []ParameterDefinition // Parameters in HTTP headers
                                                                                            	QueryParams         []ParameterDefinition // Parameters in the query, /path?param
                                                                                            	CookieParams        []ParameterDefinition // Parameters in cookies
                                                                                            	TypeDefinitions     []TypeDefinition      // These are all the types we need to define for this operation
                                                                                            	SecurityDefinitions []SecurityDefinition  // These are the security providers
                                                                                            	BodyRequired        bool
                                                                                            	Bodies              []RequestBodyDefinition // The list of bodies for which to generate handlers.
                                                                                            	Summary             string                  // Summary string from Swagger, used to generate a comment
                                                                                            	Method              string                  // GET, POST, DELETE, etc.
                                                                                            	Path                string                  // The Swagger path for the operation, like /resource/{id}
                                                                                            	Spec                *openapi3.Operation
                                                                                            }

                                                                                              This structure describes an Operation

                                                                                              func OperationDefinitions

                                                                                              func OperationDefinitions(swagger *openapi3.Swagger) ([]OperationDefinition, error)

                                                                                                OperationDefinitions returns all operations for a swagger definition.

                                                                                                func (*OperationDefinition) AllParams

                                                                                                func (o *OperationDefinition) AllParams() []ParameterDefinition

                                                                                                  Returns all parameters

                                                                                                  func (*OperationDefinition) GetResponseTypeDefinitions

                                                                                                  func (o *OperationDefinition) GetResponseTypeDefinitions() ([]TypeDefinition, error)

                                                                                                    Produces a list of type definitions for a given Operation for the response types which we know how to parse. These will be turned into fields on a response object for automatic deserialization of responses in the generated Client code. See "client-with-responses.tmpl".

                                                                                                    func (*OperationDefinition) HasBody

                                                                                                    func (o *OperationDefinition) HasBody() bool

                                                                                                      This is called by the template engine to determine whether to generate body marshaling code on the client. This is true for all body types, whether or not we generate types for them.

                                                                                                      func (*OperationDefinition) Params

                                                                                                        Returns the list of all parameters except Path parameters. Path parameters are handled differently from the rest, since they're mandatory.

                                                                                                        func (*OperationDefinition) RequiresParamObject

                                                                                                        func (o *OperationDefinition) RequiresParamObject() bool

                                                                                                          If we have parameters other than path parameters, they're bundled into an object. Returns true if we have any of those. This is used from the template engine.

                                                                                                          func (*OperationDefinition) SummaryAsComment

                                                                                                          func (o *OperationDefinition) SummaryAsComment() string

                                                                                                            This returns the Operations summary as a multi line comment

                                                                                                            type Options

                                                                                                            type Options struct {
                                                                                                            	GenerateChiServer   bool              // GenerateChiServer specifies whether to generate chi server boilerplate
                                                                                                            	GenerateEchoServer  bool              // GenerateEchoServer specifies whether to generate echo server boilerplate
                                                                                                            	GenerateClient      bool              // GenerateClient specifies whether to generate client boilerplate
                                                                                                            	GenerateTypes       bool              // GenerateTypes specifies whether to generate type definitions
                                                                                                            	EmbedSpec           bool              // Whether to embed the swagger spec in the generated code
                                                                                                            	SkipFmt             bool              // Whether to skip go imports on the generated code
                                                                                                            	SkipPrune           bool              // Whether to skip pruning unused components on the generated code
                                                                                                            	ValidatingUnmarshal bool              // Whether to produce an unmarshalJSON method in the generated code
                                                                                                            	IncludeTags         []string          // Only include operations that have one of these tags. Ignored when empty.
                                                                                                            	ExcludeTags         []string          // Exclude operations that have one of these tags. Ignored when empty.
                                                                                                            	UserTemplates       map[string]string // Override built-in templates from user-provided files
                                                                                                            	ImportMapping       map[string]string // ImportMapping specifies the golang package path for each external reference
                                                                                                            	ExcludeSchemas      []string          // Exclude from generation schemas with given names. Ignored when empty.
                                                                                                            }

                                                                                                              Options defines the optional code to generate.

                                                                                                              type ParameterDefinition

                                                                                                              type ParameterDefinition struct {
                                                                                                              	ParamName string // The original json parameter name, eg param_name
                                                                                                              	In        string // Where the parameter is defined - path, header, cookie, query
                                                                                                              	Required  bool   // Is this a required parameter?
                                                                                                              	Spec      *openapi3.Parameter
                                                                                                              	Schema    Schema
                                                                                                              }

                                                                                                              func DescribeParameters

                                                                                                              func DescribeParameters(params openapi3.Parameters, path []string) ([]ParameterDefinition, error)

                                                                                                                This function walks the given parameters dictionary, and generates the above descriptors into a flat list. This makes it a lot easier to traverse the data in the template engine.

                                                                                                                func FilterParameterDefinitionByType

                                                                                                                func FilterParameterDefinitionByType(params []ParameterDefinition, in string) []ParameterDefinition

                                                                                                                  This function returns the subset of the specified parameters which are of the specified type.

                                                                                                                  func SortParamsByPath

                                                                                                                  func SortParamsByPath(path string, in []ParameterDefinition) ([]ParameterDefinition, error)

                                                                                                                    Reorders the given parameter definitions to match those in the path URI.

                                                                                                                    func (*ParameterDefinition) Explode

                                                                                                                    func (pd *ParameterDefinition) Explode() bool

                                                                                                                    func (ParameterDefinition) GoName

                                                                                                                    func (pd ParameterDefinition) GoName() string

                                                                                                                    func (ParameterDefinition) GoVariableName

                                                                                                                    func (pd ParameterDefinition) GoVariableName() string

                                                                                                                    func (ParameterDefinition) IndirectOptional

                                                                                                                    func (pd ParameterDefinition) IndirectOptional() bool

                                                                                                                    func (*ParameterDefinition) IsJson

                                                                                                                    func (pd *ParameterDefinition) IsJson() bool

                                                                                                                    func (*ParameterDefinition) IsPassThrough

                                                                                                                    func (pd *ParameterDefinition) IsPassThrough() bool

                                                                                                                    func (*ParameterDefinition) IsStyled

                                                                                                                    func (pd *ParameterDefinition) IsStyled() bool

                                                                                                                    func (*ParameterDefinition) JsonTag

                                                                                                                    func (pd *ParameterDefinition) JsonTag() string

                                                                                                                      Generate the JSON annotation to map GoType to json type name. If Parameter Foo is marshaled to json as "foo", this will create the annotation 'json:"foo"'

                                                                                                                      func (*ParameterDefinition) Style

                                                                                                                      func (pd *ParameterDefinition) Style() string

                                                                                                                      func (ParameterDefinition) TypeDef

                                                                                                                      func (pd ParameterDefinition) TypeDef() string

                                                                                                                        This function is here as an adapter after a large refactoring so that I don't have to update all the templates. It returns the type definition for a parameter, without the leading '*' for optional ones.

                                                                                                                        type ParameterDefinitions

                                                                                                                        type ParameterDefinitions []ParameterDefinition

                                                                                                                        func (ParameterDefinitions) FindByName

                                                                                                                        func (p ParameterDefinitions) FindByName(name string) *ParameterDefinition

                                                                                                                        type Property

                                                                                                                        type Property struct {
                                                                                                                        	Description   string
                                                                                                                        	JsonFieldName string
                                                                                                                        	Schema        Schema
                                                                                                                        	Required      bool
                                                                                                                        	Nullable      bool
                                                                                                                        }

                                                                                                                        func (Property) GoFieldName

                                                                                                                        func (p Property) GoFieldName() string

                                                                                                                        func (Property) GoTypeDef

                                                                                                                        func (p Property) GoTypeDef() string

                                                                                                                        type RefWrapper

                                                                                                                        type RefWrapper struct {
                                                                                                                        	Ref       string
                                                                                                                        	HasValue  bool
                                                                                                                        	SourceRef interface{}
                                                                                                                        }

                                                                                                                        type RequestBodyDefinition

                                                                                                                        type RequestBodyDefinition struct {
                                                                                                                        	// Is this body required, or optional?
                                                                                                                        	Required bool
                                                                                                                        
                                                                                                                        	// This is the schema describing this body
                                                                                                                        	Schema Schema
                                                                                                                        
                                                                                                                        	// When we generate type names, we need a Tag for it, such as JSON, in
                                                                                                                        	// which case we will produce "JSONBody".
                                                                                                                        	NameTag string
                                                                                                                        
                                                                                                                        	// This is the content type corresponding to the body, eg, application/json
                                                                                                                        	ContentType string
                                                                                                                        
                                                                                                                        	// Whether this is the default body type. For an operation named OpFoo, we
                                                                                                                        	// will not add suffixes like OpFooJSONBody for this one.
                                                                                                                        	Default bool
                                                                                                                        }

                                                                                                                          This describes a request body

                                                                                                                          func (RequestBodyDefinition) CustomType

                                                                                                                          func (r RequestBodyDefinition) CustomType() bool

                                                                                                                            Returns whether the body is a custom inline type, or pre-defined. This is poorly named, but it's here for compatibility reasons post-refactoring TODO: clean up the templates code, it can be simpler.

                                                                                                                            func (RequestBodyDefinition) Suffix

                                                                                                                            func (r RequestBodyDefinition) Suffix() string

                                                                                                                              When we're generating multiple functions which relate to request bodies, this generates the suffix. Such as Operation DoFoo would be suffixed with DoFooWithXMLBody.

                                                                                                                              func (RequestBodyDefinition) TypeDef

                                                                                                                              func (r RequestBodyDefinition) TypeDef() string

                                                                                                                                Returns the Go type definition for a request body

                                                                                                                                type Schema

                                                                                                                                type Schema struct {
                                                                                                                                	GoType  string // The Go type needed to represent the schema
                                                                                                                                	RefType string // If the type has a type name, this is set
                                                                                                                                
                                                                                                                                	EnumValues    map[string]string // Enum values
                                                                                                                                	EmbeddedTypes []string          // Types emebedded by allOf
                                                                                                                                
                                                                                                                                	Properties               []Property       // For an object, the fields with names
                                                                                                                                	HasAdditionalProperties  bool             // Whether we support additional properties
                                                                                                                                	AdditionalPropertiesType *Schema          // And if we do, their type
                                                                                                                                	AdditionalTypes          []TypeDefinition // We may need to generate auxiliary helper types, stored here
                                                                                                                                
                                                                                                                                	SkipOptionalPointer bool // Some types don't need a * in front when they're optional
                                                                                                                                }

                                                                                                                                  This describes a Schema, a type definition.

                                                                                                                                  func GenerateGoSchema

                                                                                                                                  func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error)

                                                                                                                                  func MergeSchemas

                                                                                                                                  func MergeSchemas(allOf []*openapi3.SchemaRef, path []string) (Schema, error)

                                                                                                                                    Merge all the fields in the schemas supplied into one giant schema.

                                                                                                                                    func (Schema) GetAdditionalTypeDefs

                                                                                                                                    func (s Schema) GetAdditionalTypeDefs() []TypeDefinition

                                                                                                                                    func (Schema) IsRef

                                                                                                                                    func (s Schema) IsRef() bool

                                                                                                                                    func (*Schema) MergeProperty

                                                                                                                                    func (s *Schema) MergeProperty(p Property) error

                                                                                                                                    func (Schema) TypeDecl

                                                                                                                                    func (s Schema) TypeDecl() string

                                                                                                                                    type SchemaDescriptor

                                                                                                                                    type SchemaDescriptor struct {
                                                                                                                                    	Fields                   []FieldDescriptor
                                                                                                                                    	HasAdditionalProperties  bool
                                                                                                                                    	AdditionalPropertiesType string
                                                                                                                                    }

                                                                                                                                      This describes a Schema, a type definition.

                                                                                                                                      type SecurityDefinition

                                                                                                                                      type SecurityDefinition struct {
                                                                                                                                      	ProviderName string
                                                                                                                                      	Scopes       []string
                                                                                                                                      }

                                                                                                                                      func DescribeSecurityDefinition

                                                                                                                                      func DescribeSecurityDefinition(securityRequirements openapi3.SecurityRequirements) []SecurityDefinition

                                                                                                                                      type TypeDefinition

                                                                                                                                      type TypeDefinition struct {
                                                                                                                                      	TypeName     string
                                                                                                                                      	JsonName     string
                                                                                                                                      	ResponseName string
                                                                                                                                      	Schema       Schema
                                                                                                                                      }

                                                                                                                                      func GenerateParamsTypes

                                                                                                                                      func GenerateParamsTypes(op OperationDefinition) []TypeDefinition

                                                                                                                                        This defines the schema for a parameters definition object which encapsulates all the query, header and cookie parameters for an operation.

                                                                                                                                        func GenerateTypeDefsForOperation

                                                                                                                                        func GenerateTypeDefsForOperation(op OperationDefinition) []TypeDefinition

                                                                                                                                        func GenerateTypesForParameters

                                                                                                                                        func GenerateTypesForParameters(t *template.Template, params map[string]*openapi3.ParameterRef) ([]TypeDefinition, error)

                                                                                                                                          Generates type definitions for any custom types defined in the components/parameters section of the Swagger spec.

                                                                                                                                          func GenerateTypesForRequestBodies

                                                                                                                                          func GenerateTypesForRequestBodies(t *template.Template, bodies map[string]*openapi3.RequestBodyRef) ([]TypeDefinition, error)

                                                                                                                                            Generates type definitions for any custom types defined in the components/requestBodies section of the Swagger spec.

                                                                                                                                            func GenerateTypesForResponses

                                                                                                                                            func GenerateTypesForResponses(t *template.Template, responses openapi3.Responses) ([]TypeDefinition, error)

                                                                                                                                              Generates type definitions for any custom types defined in the components/responses section of the Swagger spec.

                                                                                                                                              func GenerateTypesForSchemas

                                                                                                                                              func GenerateTypesForSchemas(t *template.Template, schemas map[string]*openapi3.SchemaRef, excludeSchemas []string) ([]TypeDefinition, error)

                                                                                                                                                Generates type definitions for any custom types defined in the components/schemas section of the Swagger spec.

                                                                                                                                                Directories

                                                                                                                                                Path Synopsis