spec

Documentation

Index

• Constants
• type Components
• type ExpansionResources
• type Fixtures
• type HTTPVerb
• type Info
• type MediaType
• type Operation
• type Parameter
• type Path
• type RequestBody
• type ResourceID
• type Response
• type Schema
  • func (s *Schema) String() string
  • func (s *Schema) UnmarshalJSON(data []byte) error
• type Spec
  • func LoadSpec(specPath string) (*Spec, error)
• type StatusCode
• type StripeOperation

Constants

const (
	ParameterPath  = "path"
	ParameterQuery = "query"
)

A set of constants for the different types of possible OpenAPI parameters.

const (
	TypeArray   = "array"
	TypeBoolean = "boolean"
	TypeInteger = "integer"
	TypeNumber  = "number"
	TypeObject  = "object"
	TypeString  = "string"
)

A set of constant for the named types available in JSON Schema.

Types

type Components

type Components struct {
	Schemas map[string]*Schema `json:"schemas"`
}

Components is a struct for the components section of an OpenAPI specification.

type ExpansionResources

type ExpansionResources struct {
	OneOf []*Schema `json:"oneOf"`
}

ExpansionResources is a struct for possible expansions in a resource.

type Fixtures

type Fixtures struct {
	Resources map[ResourceID]interface{} `json:"resources"`
}

Fixtures is a struct for a set of companion fixtures for an OpenAPI specification.

type HTTPVerb

type HTTPVerb string

HTTPVerb is a type for an HTTP verb like GET, POST, etc.

type Info

type Info struct {
	// Version is the Stripe API version represented in the specification. It
	// takes a date-based form like `2019-02-19`.
	Version string `json:"version"`
}

Info is the `info` portion of an OpenAPI specification that contains meta information about it.

type MediaType

type MediaType struct {
	Schema *Schema `json:"schema"`
}

MediaType is a struct bucketing a request or response by media type in an OpenAPI specification.

type Operation

type Operation struct {
	Deprecated  *bool                   `json:"deprecated"`
	Description string                  `json:"description"`
	OperationID string                  `json:"operation_id"`
	Parameters  []*Parameter            `json:"parameters"`
	RequestBody *RequestBody            `json:"requestBody"`
	Responses   map[StatusCode]Response `json:"responses"`
}

Operation is a struct representing a possible HTTP operation in an OpenAPI specification.

type Parameter

type Parameter struct {
	Description string  `json:"description"`
	In          string  `json:"in"`
	Name        string  `json:"name"`
	Required    bool    `json:"required"`
	Schema      *Schema `json:"schema"`
}

Parameter is a struct representing a request parameter to an HTTP operation in an OpenAPI specification.

type Path

type Path string

Path is a type for an HTTP path in an OpenAPI specification.

type RequestBody

type RequestBody struct {
	Content  map[string]MediaType `json:"content"`
	Required bool                 `json:"required"`
}

RequestBody is a struct representing the body of a request in an OpenAPI specification.

type ResourceID

type ResourceID string

ResourceID is a type for the ID of a response resource in an OpenAPI specification.

type Response

type Response struct {
	Description string               `json:"description"`
	Content     map[string]MediaType `json:"content"`
}

Response is a struct representing the response of an HTTP operation in an OpenAPI specification.

type Schema

type Schema struct {
	// AdditionalProperties is either a `false` to indicate that no additional
	// properties in the object are allowed (beyond what's in Properties), or a
	// JSON schema that describes the expected format of any additional properties.
	//
	// We currently just read it as an `interface{}` because we're not using it
	// for anything right now.
	AdditionalProperties interface{} `json:"additionalProperties,omitempty"`

	AnyOf      []*Schema          `json:"anyOf,omitempty"`
	Enum       []interface{}      `json:"enum,omitempty"`
	Format     string             `json:"format,omitempty"`
	Items      *Schema            `json:"items,omitempty"`
	MaxLength  int                `json:"maxLength,omitempty"`
	Nullable   bool               `json:"nullable,omitempty"`
	Pattern    string             `json:"pattern,omitempty"`
	Properties map[string]*Schema `json:"properties,omitempty"`
	Required   []string           `json:"required,omitempty"`
	Type       string             `json:"type,omitempty"`

	// Ref is populated if this JSON Schema is actually a JSON reference, and
	// it defines the location of the actual schema definition.
	Ref string `json:"$ref,omitempty"`

	XExpandableFields   *[]string           `json:"x-expandableFields,omitempty"`
	XExpansionResources *ExpansionResources `json:"x-expansionResources,omitempty"`
	XResourceID         string              `json:"x-resourceId,omitempty"`
	XStripeOperations   *[]StripeOperation  `json:"x-stripeOperations,omitempty"`
	XStripeMostCommon   []string            `json:"x-stripeMostCommon,omitempty"`
}

Schema is a struct representing a JSON schema.

func (*Schema) String

func (s *Schema) String() string

func (*Schema) UnmarshalJSON

func (s *Schema) UnmarshalJSON(data []byte) error

UnmarshalJSON is a custom JSON unmarshaling implementation for Schema that provides better error messages instead of silently ignoring fields.

type Spec

type Spec struct {
	Components Components                       `json:"components"`
	Info       *Info                            `json:"info"`
	Paths      map[Path]map[HTTPVerb]*Operation `json:"paths"`
}

Spec is a struct representing an OpenAPI specification.

func LoadSpec

func LoadSpec(specPath string) (*Spec, error)

LoadSpec loads and returns the OpenAPI spec.

type StatusCode

type StatusCode string

StatusCode is a type for the response status code of an HTTP operation in an OpenAPI specification.

type StripeOperation

type StripeOperation struct {
	MethodName string   `json:"method_name"`
	MethodOn   string   `json:"method_on"`
	MethodType string   `json:"method_type"`
	Operation  HTTPVerb `json:"operation"`
	Path       string   `json:"path"`
}

StripeOperation is a struct for possible operations on a resource.