openapi

type Array ¶

type Array struct {
	BaseSchema

	SubType Schema
}

Array must have all its element of the same `SubType`.

func (a *Array) Accept(v SchemaVisitor)

func (a *Array) GetName() string

type BaseSchema ¶ added in v1.8.0

type BaseSchema struct {
	Description string
	Extensions  map[string]interface{}

	Path Path
}

BaseSchema holds data used by each types of schema.

func (b *BaseSchema) GetDescription() string

func (b *BaseSchema) GetExtensions() map[string]interface{}

func (b *BaseSchema) GetPath() *Path

type Definitions ¶ added in v1.8.0

type Definitions struct {
	// contains filtered or unexported fields
}

Definitions is an implementation of `Resources`. It looks for resources in an openapi Schema.

func (d *Definitions) LookupResource(gvk schema.GroupVersionKind) Schema

func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error)

type Getter ¶

type Getter interface {
	// OpenAPIData returns the parsed OpenAPIData
	Get() (Resources, error)
}

Getter is an interface for fetching openapi specs and parsing them into an Resources struct

func NewOpenAPIGetter(openAPIClient discovery.OpenAPISchemaInterface) Getter

type Kind ¶

type Kind struct {
	BaseSchema

	// Lists names of required fields.
	RequiredFields []string
	// Maps field names to types.
	Fields map[string]Schema
}

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 (k *Kind) Accept(v SchemaVisitor)

func (k *Kind) GetName() string

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 (m *Map) Accept(v SchemaVisitor)

func (m *Map) GetName() string

type Path ¶ added in v1.8.0

type Path struct {
	// contains filtered or unexported fields
}

Path helps us keep track of type paths

func NewPath(key string) Path

func (p *Path) ArrayPath(i int) Path

func (p *Path) FieldPath(field string) Path

func (p *Path) Get() []string

func (p *Path) Len() int

func (p *Path) String() string

type Primitive ¶ added in v1.8.0

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 (p *Primitive) Accept(v SchemaVisitor)

func (p *Primitive) GetName() string

type Ref ¶ added in v1.8.0

type Ref struct {
	BaseSchema
	// contains filtered or unexported fields
}

func (r *Ref) Accept(v SchemaVisitor)

func (r *Ref) GetName() string

func (r *Ref) Reference() string

func (r *Ref) SubSchema() Schema

type Reference ¶ added in v1.8.0

type Reference interface {
	Schema

	Reference() string
	SubSchema() Schema
}

Reference implementation depends on the type of document.

type Resources ¶

type Resources interface {
	LookupResource(gvk schema.GroupVersionKind) Schema
}

Resources interface describe a resources provider, that can give you resource based on group-version-kind.

func NewOpenAPIData(doc *openapi_v2.Document) (Resources, error)

type Schema ¶ added in v1.8.0

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
	// Returns type extensions.
	GetExtensions() map[string]interface{}
}

Schema is the base definition of an openapi type.

type SchemaVisitor ¶ added in v1.8.0

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.