Documentation ¶
Overview ¶
Package proto is a collection of libraries for parsing and indexing the type definitions. The openapi spec contains the object model definitions and extensions metadata.
Index ¶
Constants ¶
const ( Integer = "integer" Number = "number" String = "string" Boolean = "boolean" )
Defines openapi types.
Variables ¶
This section is empty.
Functions ¶
func VendorExtensionToMap ¶
func VendorExtensionToMap(e []*openapi_v2.NamedAny) map[string]interface{}
VendorExtensionToMap converts openapi VendorExtension to a map.
Types ¶
type Arbitrary ¶
type Arbitrary struct {
BaseSchema
}
Arbitrary is a value of any type (primitive, object or array)
func (*Arbitrary) Accept ¶
func (a *Arbitrary) Accept(v SchemaVisitor)
type Array ¶
type Array struct { BaseSchema SubType Schema }
Array must have all its element of the same `SubType`.
func (*Array) Accept ¶
func (a *Array) Accept(v SchemaVisitor)
type BaseSchema ¶
type BaseSchema struct { Description string Extensions map[string]interface{} Default interface{} Path Path }
BaseSchema holds data used by each types of schema.
func (*BaseSchema) GetDefault ¶
func (b *BaseSchema) GetDefault() interface{}
func (*BaseSchema) GetDescription ¶
func (b *BaseSchema) GetDescription() string
func (*BaseSchema) GetExtensions ¶
func (b *BaseSchema) GetExtensions() map[string]interface{}
func (*BaseSchema) GetPath ¶
func (b *BaseSchema) GetPath() *Path
type Definitions ¶
type Definitions struct {
// contains filtered or unexported fields
}
Definitions is an implementation of `Models`. It looks for models in an openapi Schema.
func (*Definitions) ListModels ¶
func (d *Definitions) ListModels() []string
func (*Definitions) LookupModel ¶
func (d *Definitions) LookupModel(model string) Schema
LookupModel is public through the interface of Models. It returns a visitable schema from the given model name.
func (*Definitions) ParseSchema ¶
func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error)
ParseSchema creates a walkable Schema from an openapi schema. While this function is public, it doesn't leak through the interface.
type Kind ¶
type Kind struct { BaseSchema // Lists names of required fields. RequiredFields []string // Maps field names to types. Fields map[string]Schema // FieldOrder reports the canonical order for the fields. FieldOrder []string }
Kind is a complex object. It can have multiple different subtypes for each field, as defined in the `Fields` field. Mandatory fields are listed in `RequiredFields`. The key of the object is always of type `string`.
func (*Kind) Accept ¶
func (k *Kind) Accept(v SchemaVisitor)
func (*Kind) IsRequired ¶
IsRequired returns true if `field` is a required field for this type.
type Map ¶
type Map struct { BaseSchema SubType Schema }
Map is an object who values must all be of the same `SubType`. The key of the object is always of type `string`.
func (*Map) Accept ¶
func (m *Map) Accept(v SchemaVisitor)
type Models ¶
Models interface describe a model provider. They can give you the schema for a specific model.
func NewOpenAPIData ¶
func NewOpenAPIData(doc *openapi_v2.Document) (Models, error)
NewOpenAPIData creates a new `Models` out of the openapi document.
type Path ¶
type Path struct {
// contains filtered or unexported fields
}
Path helps us keep track of type paths
func (*Path) ArrayPath ¶
ArrayPath appends an array index and creates a new path
func (*Path) FieldPath ¶
FieldPath appends a field name and creates a new path
type Primitive ¶
type Primitive struct { BaseSchema // Type of a primitive must be one of: integer, number, string, boolean. Type string Format string }
Primitive is a literal. There can be multiple types of primitives, and this subtype can be visited through the `subType` field.
func (*Primitive) Accept ¶
func (p *Primitive) Accept(v SchemaVisitor)
type Ref ¶
type Ref struct { BaseSchema // contains filtered or unexported fields }
func (*Ref) Accept ¶
func (r *Ref) Accept(v SchemaVisitor)
type Reference ¶
Reference implementation depends on the type of document.
type Schema ¶
type Schema interface { // Giving a visitor here will let you visit the actual type. Accept(SchemaVisitor) // Pretty print the name of the type. GetName() string // Describes how to access this field. GetPath() *Path // Describes the field. GetDescription() string // Default for that schema. GetDefault() interface{} // Returns type extensions. GetExtensions() map[string]interface{} }
Schema is the base definition of an openapi type.
type SchemaVisitor ¶
type SchemaVisitor interface { VisitArray(*Array) VisitMap(*Map) VisitPrimitive(*Primitive) VisitKind(*Kind) VisitReference(Reference) }
SchemaVisitor is an interface that you need to implement if you want to "visit" an openapi schema. A dispatch on the Schema type will call the appropriate function based on its actual type: - Array is a list of one and only one given subtype - Map is a map of string to one and only one given subtype - Primitive can be string, integer, number and boolean. - Kind is an object with specific fields mapping to specific types. - Reference is a link to another definition.
type SchemaVisitorArbitrary ¶
type SchemaVisitorArbitrary interface { SchemaVisitor VisitArbitrary(*Arbitrary) }
SchemaVisitorArbitrary is an additional visitor interface which handles arbitrary types. For backwards compatibility, it's a separate interface which is checked for at runtime.