View Source

var DefaultTypeMapping = TypeMapping{
	Integer: FormatMapping{
		Default: SimpleTypeSpec{Type: "int"},
		Formats: map[string]SimpleTypeSpec{
			"int":    {Type: "int"},
			"int8":   {Type: "int8"},
			"int16":  {Type: "int16"},
			"int32":  {Type: "int32"},
			"int64":  {Type: "int64"},
			"uint":   {Type: "uint"},
			"uint8":  {Type: "uint8"},
			"uint16": {Type: "uint16"},
			"uint32": {Type: "uint32"},
			"uint64": {Type: "uint64"},
		},
	},
	Number: FormatMapping{
		Default: SimpleTypeSpec{Type: "float32"},
		Formats: map[string]SimpleTypeSpec{
			"float":  {Type: "float32"},
			"double": {Type: "float64"},
		},
	},
	Boolean: FormatMapping{
		Default: SimpleTypeSpec{Type: "bool"},
	},
	String: FormatMapping{
		Default: SimpleTypeSpec{Type: "string"},
		Formats: map[string]SimpleTypeSpec{
			"byte":      {Type: "[]byte"},
			"email":     {Type: "openapi_types.Email"},
			"date":      {Type: "openapi_types.Date"},
			"date-time": {Type: "time.Time", Import: "time"},
			"json":      {Type: "json.RawMessage", Import: "encoding/json"},
			"uuid":      {Type: "openapi_types.UUID"},
			"binary":    {Type: "openapi_types.File"},
		},
	},
}

View Source

var TemplateFunctions = template.FuncMap{
	"genParamArgs":               genParamArgs,
	"genParamTypes":              genParamTypes,
	"genParamNames":              genParamNames,
	"genParamFmtString":          ReplacePathParamsWithStr,
	"swaggerUriToIrisUri":        SwaggerUriToIrisUri,
	"swaggerUriToEchoUri":        SwaggerUriToEchoUri,
	"swaggerUriToFiberUri":       SwaggerUriToFiberUri,
	"swaggerUriToChiUri":         SwaggerUriToChiUri,
	"swaggerUriToGinUri":         SwaggerUriToGinUri,
	"swaggerUriToGorillaUri":     SwaggerUriToGorillaUri,
	"swaggerUriToStdHttpUri":     SwaggerUriToStdHttpUri,
	"lcFirst":                    LowercaseFirstCharacter,
	"ucFirst":                    UppercaseFirstCharacter,
	"ucFirstWithPkgName":         UppercaseFirstCharacterWithPkgName,
	"camelCase":                  ToCamelCase,
	"genResponsePayload":         genResponsePayload,
	"genResponseTypeName":        genResponseTypeName,
	"genResponseUnmarshal":       genResponseUnmarshal,
	"getResponseTypeDefinitions": getResponseTypeDefinitions,
	"toStringArray":              toStringArray,
	"lower":                      strings.ToLower,
	"title":                      titleCaser.String,
	"stripNewLines":              stripNewLines,
	"sanitizeGoIdentity":         SanitizeGoIdentity,
	"toGoString":                 StringToGoString,
	"toGoComment":                StringWithTypeNameToGoComment,

	"genServerURLWithVariablesFunctionParams": genServerURLWithVariablesFunctionParams,
}

EscapePathElements breaks apart a path, and looks at each element. If it's not a path parameter, eg, {param}, it will URL-escape the element.

func GenFieldsFromProperties(props []Property) []string

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

GenStructFromAllOf 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(schema Schema) string

Generate 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

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

func GenerateBodyDefinitions ¶

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

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

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

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

GenerateConstants generates operation ids, context keys, paths, etc. to be exported as constants

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

GenerateFiberServer generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

GenerateGinServer generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

GenerateGorillaServer generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

GenerateImports generates our import statements and package definition.

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

GenerateIrisServer generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

GenerateStdHTTPServer generates all the go code for the ServerInterface as well as all the wrapper functions around our handlers.

GenerateTemplates used to generate templates

GenerateTypes passes a bunch of types to the template engine, and buffers its output into a string.

GenerateTypesForOperations generates code for all types produced within operations

GetUserTemplateText attempts to retrieve the template text from a passed in URL or file path when inputData is more than one line. This function will attempt to load a file first, and if it fails, will try to get the data from the remote endpoint. The timeout for remote download file is 30 seconds.

IsGoKeyword returns whether the given string is a go keyword

IsGoTypeReference takes a $ref value and checks if it has link to go type. #/components/schemas/Foo -> true ./local/file.yml#/components/parameters/Bar -> true ./local/file.yml -> false IsGoTypeReference can be used to check whether RefPathToGoType($ref) is possible.

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

LoadTemplates loads all of our template files into a text/template. The path of template is relative to the templates directory.

LowercaseFirstCharacter Lowercases 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.

Lowercase the first upper characters in a string for case of abbreviation. This assumes UTF-8, so we have to be careful with unicode, don't treat it as a byte array.

func MergeImports(dst, src map[string]goImport)

func OperationSchemaImports(s *Schema) (map[string]goImport, error)

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

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

func PropertiesEqual(a, b Property) bool

RefPathToGoType 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 Remote and URL also support standard local paths even though the spec doesn't mention them.

RefPathToObjName returns the name of referenced object without changes.

#/components/schemas/Foo -> Foo
#/components/parameters/Bar -> Bar
#/components/responses/baz_baz -> baz_baz
document.json#/Foo -> Foo
http://deepmap.com/schemas/document.json#/objObj -> objObj

Does not check refPath correctness.

ReplacePathParamsWithStr replaces path parameters of the form {param} with %s

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

SanitizeEnumNames fixes illegal chars in the enum names and removes duplicates

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

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.

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

SortedMapKeys takes a map with keys of type string and returns a slice of those keys sorted lexicographically.

SortedSchemaKeys returns the keys of the given SchemaRef dictionary in sorted order, since Golang scrambles dictionary keys. This isn't a generic key sort, because we support an extension to grant specific orders to schemas to help control output ordering.

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

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

StringToGoString takes an arbitrary string and converts it to a valid Go string literal, including the quotes. For instance, `foo "bar"` would be converted to `"foo \"bar\""`

func StringWithTypeNameToGoComment(in, typeName string) string

StringWithTypeNameToGoComment renders a possible multi-line string as a valid Go-Comment, including the name of the type being referenced. Each line is prefixed as a comment.

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

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

SwaggerUriToEchoUri converts a OpenAPI style path URI with parameters to an Echo compatible path URI. We need to replace all of OpenAPI parameters with ":param". Valid input parameters are:

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

SwaggerUriToFiberUri converts a OpenAPI style path URI with parameters to a Fiber compatible path URI. We need to replace all of OpenAPI parameters with ":param". Valid input parameters are:

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

SwaggerUriToGinUri converts a swagger style path URI with parameters to a Gin compatible path URI. We need to replace all Swagger parameters with ":param". Valid input parameters are:

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

SwaggerUriToGorillaUri converts a swagger style path URI with parameters to a Gorilla compatible path URI. We need to replace all Swagger parameters with ":param". Valid input parameters are:

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

SwaggerUriToIrisUri converts a OpenAPI style path URI with parameters to an Iris compatible path URI. We need to replace all of OpenAPI parameters with

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

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

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

ToCamelCase 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

ToCamelCaseWithDigits function will convert query-arg style strings to CamelCase. We will use `., -, +, :, ;, _, ~, ' ', (, ), {, }, [, ]` as valid delimiters for words. The difference of ToCamelCase that letter after a number becomes capitalized. So, "word.word-word+word:word;word_word~word word(word)word{word}[word]3word" would be converted to WordWordWordWordWordWordWordWordWordWordWordWordWord3Word

ToCamelCaseWithInitialisms function will convert query-arg style strings to CamelCase with initialisms in uppercase. So, httpOperationId would be converted to HTTPOperationID

func TypeDefinitionsEquivalent(t1, t2 TypeDefinition) bool

TypeDefinitionsEquivalent checks for equality between two type definitions, but not every field is considered. We only want to know if they are fundamentally the same type.

UppercaseFirstCharacter Uppercases 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.

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

type AdditionalImport struct {
	Alias   string `yaml:"alias,omitempty"`
	Package string `yaml:"package"`
}

type CompatibilityOptions struct {
	
	
	
	
	
	
	OldMergeSchemas bool `yaml:"old-merge-schemas,omitempty"`
	
	
	
	
	
	OldEnumConflicts bool `yaml:"old-enum-conflicts,omitempty"`
	
	
	
	
	
	OldAliasing bool `yaml:"old-aliasing,omitempty"`
	
	
	DisableFlattenAdditionalProperties bool `yaml:"disable-flatten-additional-properties,omitempty"`
	
	
	
	DisableRequiredReadOnlyAsPointer bool `yaml:"disable-required-readonly-as-pointer,omitempty"`
	
	
	AlwaysPrefixEnumValues bool `yaml:"always-prefix-enum-values,omitempty"`
	
	
	
	
	ApplyChiMiddlewareFirstToLast bool `yaml:"apply-chi-middleware-first-to-last,omitempty"`
	
	
	
	
	ApplyGorillaMiddlewareFirstToLast bool `yaml:"apply-gorilla-middleware-first-to-last,omitempty"`
	
	
	
	
	
	CircularReferenceLimit int `yaml:"circular-reference-limit"`
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	AllowUnexportedStructFieldNames bool `yaml:"allow-unexported-struct-field-names"`

	
	
	
	
	
	
	PreserveOriginalOperationIdCasingInEmbeddedSpec bool `yaml:"preserve-original-operation-id-casing-in-embedded-spec"`
}

CompatibilityOptions specifies backward compatibility settings for the code generator.

ComponentType is used to keep track of where a given schema came from, in order to perform type name collision resolution.

type Configuration struct {
	
	PackageName string `yaml:"package"`
	
	Generate GenerateOptions `yaml:"generate,omitempty"`
	
	Compatibility CompatibilityOptions `yaml:"compatibility,omitempty"`
	
	OutputOptions OutputOptions `yaml:"output-options,omitempty"`
	
	ImportMapping map[string]string `yaml:"import-mapping,omitempty"`
	
	AdditionalImports []AdditionalImport `yaml:"additional-imports,omitempty"`
	
	
	NoVCSVersionOverride *string `yaml:"-"`
}

Configuration defines code generation customizations

func (o Configuration) UpdateDefaults() Configuration

type Constants struct {
	
	SecuritySchemeProviderNames []string
	
	EnumDefinitions []EnumDefinition
}

type EnumDefinition struct {
	
	
	Schema Schema
	
	TypeName string
	
	
	ValueWrapper string
	
	
	
	
	PrefixTypeName bool
}

EnumDefinition holds type information for enum

type FormatMapping struct {
	Default SimpleTypeSpec            `yaml:"default" json:"default"`
	Formats map[string]SimpleTypeSpec `yaml:"formats,omitempty" json:"formats,omitempty"`
}

FormatMapping defines the default Go type and format-specific overrides for an OpenAPI type.

type GenerateOptions struct {
	
	IrisServer bool `yaml:"iris-server,omitempty"`
	
	ChiServer bool `yaml:"chi-server,omitempty"`
	
	FiberServer bool `yaml:"fiber-server,omitempty"`
	
	EchoServer bool `yaml:"echo-server,omitempty"`
	
	GinServer bool `yaml:"gin-server,omitempty"`
	
	GorillaServer bool `yaml:"gorilla-server,omitempty"`
	
	StdHTTPServer bool `yaml:"std-http-server,omitempty"`
	
	Strict bool `yaml:"strict-server,omitempty"`
	
	Client bool `yaml:"client,omitempty"`
	
	Models bool `yaml:"models,omitempty"`
	
	EmbeddedSpec bool `yaml:"embedded-spec,omitempty"`
	
	ServerURLs bool `yaml:"server-urls,omitempty"`
}

GenerateOptions specifies which supported output formats to generate.

NameNormalizer is a function that takes a type name, and returns that type name converted into a different format.

This may be an Operation ID i.e. `retrieveUserRequests` or a Schema name i.e. `BigBlockOfCheese`

NOTE: this must return a string that can be used as a valid Go type name

type NameNormalizerMap map[NameNormalizerFunction]NameNormalizer

OperationDefinition describes an Operation

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

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

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

func (o *OperationDefinition) RequiresParamObject() bool

type OutputOptions struct {
	
	SkipFmt bool `yaml:"skip-fmt,omitempty"`
	
	SkipPrune bool `yaml:"skip-prune,omitempty"`
	
	IncludeTags []string `yaml:"include-tags,omitempty"`
	
	ExcludeTags []string `yaml:"exclude-tags,omitempty"`
	
	IncludeOperationIDs []string `yaml:"include-operation-ids,omitempty"`
	
	ExcludeOperationIDs []string `yaml:"exclude-operation-ids,omitempty"`
	
	UserTemplates map[string]string `yaml:"user-templates,omitempty"`

	
	ExcludeSchemas []string `yaml:"exclude-schemas,omitempty"`
	
	ResponseTypeSuffix string `yaml:"response-type-suffix,omitempty"`
	
	ClientTypeName string `yaml:"client-type-name,omitempty"`
	
	InitialismOverrides bool `yaml:"initialism-overrides,omitempty"`
	
	
	AdditionalInitialisms []string `yaml:"additional-initialisms,omitempty"`
	
	NullableType bool `yaml:"nullable-type,omitempty"`

	
	
	
	DisableTypeAliasesForType []string `yaml:"disable-type-aliases-for-type"`

	
	NameNormalizer string `yaml:"name-normalizer,omitempty"`

	
	Overlay OutputOptionsOverlay `yaml:"overlay"`

	
	EnableYamlTags bool `yaml:"yaml-tags,omitempty"`

	
	ClientResponseBytesFunction bool `yaml:"client-response-bytes-function,omitempty"`

	
	
	PreferSkipOptionalPointer bool `yaml:"prefer-skip-optional-pointer,omitempty"`

	
	
	
	
	PreferSkipOptionalPointerWithOmitzero bool `yaml:"prefer-skip-optional-pointer-with-omitzero,omitempty"`

	
	PreferSkipOptionalPointerOnContainerTypes bool `yaml:"prefer-skip-optional-pointer-on-container-types,omitempty"`

	
	
	
	
	
	
	ResolveTypeNameCollisions bool `yaml:"resolve-type-name-collisions,omitempty"`

	
	
	TypeMapping *TypeMapping `yaml:"type-mapping,omitempty"`
}

OutputOptions are used to modify the output code in some way.

type OutputOptionsOverlay struct {
	Path string `yaml:"path"`

	
	
	Strict *bool `yaml:"strict,omitempty"`
}

type ParameterDefinitions []ParameterDefinition

type RefWrapper struct {
	Ref       string
	HasValue  bool
	SourceRef any
}

type RequestBodyDefinition ¶

RequestBodyDefinition describes a request body

func (r RequestBodyDefinition) IsFixedContentType() bool

func (r RequestBodyDefinition) IsSupportedByClient() bool

type ResponseContentDefinition ¶

type ResponseContentDefinition struct {
	
	Schema Schema

	
	ContentType string

	
	
	NameTag string
}

func (r ResponseContentDefinition) HasFixedContentType() bool

type ResponseHeaderDefinition struct {
}

type ResponseTypeDefinition struct {
	TypeDefinition
	
	ContentTypeName string

	
	ResponseName string

	AdditionalTypeDefinitions []TypeDefinition
}

ResponseTypeDefinition is an extension of TypeDefinition, specifically for response unmarshaling in ClientWithResponses.

type Schema struct {
	GoType  string 
	RefType string 

	ArrayType *Schema 

	EnumValues map[string]string 

	Properties               []Property       
	HasAdditionalProperties  bool             
	AdditionalPropertiesType *Schema          
	AdditionalTypes          []TypeDefinition 

	SkipOptionalPointer bool 

	Description string 

	UnionElements []UnionElement 
	Discriminator *Discriminator 

	
	
	
	
	
	DefineViaAlias bool

	
	OAPISchema *openapi3.Schema

	DefinedComp ComponentType 
}

Schema describes an OpenAPI schema, with lots of helper fields to use in the templating engine.

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

func (s Schema) GetAdditionalTypeDefs() []TypeDefinition

func (s Schema) IsExternalRef() bool

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

SchemaDescriptor describes a Schema, a type definition.

type SecurityDefinition struct {
	ProviderName string
	Scopes       []string
}

type SimpleTypeSpec struct {
	Type   string `yaml:"type" json:"type"`
	Import string `yaml:"import,omitempty" json:"import,omitempty"`
}

SimpleTypeSpec defines the Go type for an OpenAPI type/format combination, along with any import required to use it.

type TypeDefinition struct {
	
	TypeName string

	
	
	JsonName string

	
	Schema Schema
}

TypeDefinition describes a Go type definition in generated code.

Let's use this example schema: components:

schemas:
  Person:
    type: object
    properties:
    name:
      type: string

func FixDuplicateTypeNames(typeDefs []TypeDefinition) []TypeDefinition

func GenerateParamsTypes(op OperationDefinition) []TypeDefinition

func GenerateTypeDefsForOperation(op OperationDefinition) []TypeDefinition

type TypeMapping struct {
	Integer FormatMapping `yaml:"integer,omitempty" json:"integer,omitempty"`
	Number  FormatMapping `yaml:"number,omitempty" json:"number,omitempty"`
	Boolean FormatMapping `yaml:"boolean,omitempty" json:"boolean,omitempty"`
	String  FormatMapping `yaml:"string,omitempty" json:"string,omitempty"`
}

TypeMapping defines the mapping from OpenAPI types to Go types.

func (base TypeMapping) Merge(user TypeMapping) TypeMapping

UnionElement describe union element, based on prefix externalRef\d+ and real ref name from external schema.