README

CI Go Report Card GoDoc Join Gitter Chat Channel -

Introduction

A Go project for handling OpenAPI files. We target the latest OpenAPI version (currently 3), but the project contains support for older OpenAPI versions too.

Licensed under the MIT License.

Contributors and users

The project has received pull requests from many people. Thanks to everyone!

Here's some projects that depend on kin-openapi:

Alternatives

Structure

  • openapi2 (godoc)
    • Support for OpenAPI 2 files, including serialization, deserialization, and validation.
  • openapi2conv (godoc)
    • Converts OpenAPI 2 files into OpenAPI 3 files.
  • openapi3 (godoc)
    • Support for OpenAPI 3 files, including serialization, deserialization, and validation.
  • openapi3filter (godoc)
    • Validates HTTP requests and responses
    • Provides a gorilla/mux router for OpenAPI operations
  • openapi3gen (godoc)
    • Generates *openapi3.Schema values for Go types.

Some recipes

Loading OpenAPI document

Use openapi3.Loader, which resolves all references:

doc, err := openapi3.NewLoader().LoadFromFile("swagger.json")

Getting OpenAPI operation that matches request

loader := openapi3.NewLoader()
doc, _ := loader.LoadFromData([]byte(`...`))
_ := doc.Validate(loader.Context)
router, _ := gorillamux.NewRouter(doc)
route, pathParams, _ := router.FindRoute(httpRequest)
// Do something with route.Operation

Validating HTTP requests/responses

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"log"
	"net/http"

	"github.com/getkin/kin-openapi/openapi3filter"
	legacyrouter "github.com/getkin/kin-openapi/routers/legacy"
)

func main() {
	ctx := context.Background()
	loader := &openapi3.Loader{Context: ctx}
	doc, _ := loader.LoadFromFile("openapi3_spec.json")
	_ := doc.Validate(ctx)
	router, _ := legacyrouter.NewRouter(doc)
	httpReq, _ := http.NewRequest(http.MethodGet, "/items", nil)

	// Find route
	route, pathParams, _ := router.FindRoute(httpReq)

	// Validate request
	requestValidationInput := &openapi3filter.RequestValidationInput{
		Request:    httpReq,
		PathParams: pathParams,
		Route:      route,
	}
	if err := openapi3filter.ValidateRequest(ctx, requestValidationInput); err != nil {
		panic(err)
	}

	var (
		respStatus      = 200
		respContentType = "application/json"
		respBody        = bytes.NewBufferString(`{}`)
	)

	log.Println("Response:", respStatus)
	responseValidationInput := &openapi3filter.ResponseValidationInput{
		RequestValidationInput: requestValidationInput,
		Status:                 respStatus,
		Header:                 http.Header{"Content-Type": []string{respContentType}},
	}
	if respBody != nil {
		data, _ := json.Marshal(respBody)
		responseValidationInput.SetBodyBytes(data)
	}

	// Validate response.
	if err := openapi3filter.ValidateResponse(ctx, responseValidationInput); err != nil {
		panic(err)
	}
}

Custom content type for body of HTTP request/response

By default, the library parses a body of HTTP request and response if it has one of the next content types: "text/plain" or "application/json". To support other content types you must register decoders for them:

func main() {
	// ...

	// Register a body's decoder for content type "application/xml".
	openapi3filter.RegisterBodyDecoder("application/xml", xmlBodyDecoder)

	// Now you can validate HTTP request that contains a body with content type "application/xml".
	requestValidationInput := &openapi3filter.RequestValidationInput{
		Request:    httpReq,
		PathParams: pathParams,
		Route:      route,
	}
	if err := openapi3filter.ValidateRequest(ctx, requestValidationInput); err != nil {
		panic(err)
	}

	// ...

	// And you can validate HTTP response that contains a body with content type "application/xml".
	if err := openapi3filter.ValidateResponse(ctx, responseValidationInput); err != nil {
		panic(err)
	}
}

func xmlBodyDecoder(body []byte) (interface{}, error) {
	// Decode body to a primitive, []inteface{}, or map[string]interface{}.
}

Custom function to check uniqueness of array items

By defaut, the library check unique items by below predefined function

func isSliceOfUniqueItems(xs []interface{}) bool {
	s := len(xs)
	m := make(map[string]struct{}, s)
	for _, x := range xs {
		key, _ := json.Marshal(&x)
		m[string(key)] = struct{}{}
	}
	return s == len(m)
}

In the predefined function using json.Marshal to generate a string can be used as a map key which is to support check the uniqueness of an array when the array items are objects or arrays. You can register you own function according to your input data to get better performance:

func main() {
	// ...

	// Register a customized function used to check uniqueness of array.
	openapi3.RegisterArrayUniqueItemsChecker(arrayUniqueItemsChecker)

	// ... other validate codes
}

func arrayUniqueItemsChecker(items []interface{}) bool {
	// Check the uniqueness of the input slice
}

Sub-v0 breaking API changes

v0.61.0
  • Renamed openapi2.Swagger to openapi2.T.
  • Renamed openapi2conv.FromV3Swagger to openapi2conv.FromV3.
  • Renamed openapi2conv.ToV3Swagger to openapi2conv.ToV3.
  • Renamed openapi3.LoadSwaggerFromData to openapi3.LoadFromData.
  • Renamed openapi3.LoadSwaggerFromDataWithPath to openapi3.LoadFromDataWithPath.
  • Renamed openapi3.LoadSwaggerFromFile to openapi3.LoadFromFile.
  • Renamed openapi3.LoadSwaggerFromURI to openapi3.LoadFromURI.
  • Renamed openapi3.NewSwaggerLoader to openapi3.NewLoader.
  • Renamed openapi3.Swagger to openapi3.T.
  • Renamed openapi3.SwaggerLoader to openapi3.Loader.
  • Renamed openapi3filter.ValidationHandler.SwaggerFile to openapi3filter.ValidationHandler.File.
  • Renamed routers.Route.Swagger to routers.Route.Spec.
v0.51.0
  • Type openapi3filter.Route moved to routers (and Route.Handler was dropped. See https://github.com/getkin/kin-openapi/issues/329)
  • Type openapi3filter.RouteError moved to routers (so did ErrPathNotFound and ErrMethodNotAllowed which are now RouteErrors)
  • Routers' FindRoute(...) method now takes only one argument: *http.Request
  • getkin/kin-openapi/openapi3filter.Router moved to getkin/kin-openapi/routers/legacy
  • openapi3filter.NewRouter() and its related WithSwaggerFromFile(string), WithSwagger(*openapi3.Swagger), AddSwaggerFromFile(string) and AddSwagger(*openapi3.Swagger) are all replaced with a single <router package>.NewRouter(*openapi3.Swagger)
    • NOTE: the NewRouter(doc) call now requires that the user ensures doc is valid (doc.Validate() != nil). This used to be asserted.
v0.47.0

Field (*openapi3.SwaggerLoader).LoadSwaggerFromURIFunc of type func(*openapi3.SwaggerLoader, *url.URL) (*openapi3.Swagger, error) was removed after the addition of the field (*openapi3.SwaggerLoader).ReadFromURIFunc of type func(*openapi3.SwaggerLoader, *url.URL) ([]byte, error).

Directories

Path Synopsis
Package jsoninfo provides information and functions for marshalling/unmarshalling JSON.
Package jsoninfo provides information and functions for marshalling/unmarshalling JSON.
Package openapi2 parses and writes OpenAPIv2 specification documents.
Package openapi2 parses and writes OpenAPIv2 specification documents.
Package openapi2conv converts an OpenAPI v2 specification document to v3.
Package openapi2conv converts an OpenAPI v2 specification document to v3.
Package openapi3 parses and writes OpenAPI 3 specification documents.
Package openapi3 parses and writes OpenAPI 3 specification documents.
Package openapi3filter validates that requests and inputs request an OpenAPI 3 specification file.
Package openapi3filter validates that requests and inputs request an OpenAPI 3 specification file.
Package openapi3gen generates OpenAPIv3 JSON schemas from Go types.
Package openapi3gen generates OpenAPIv3 JSON schemas from Go types.
gorillamux
Package gorillamux implements a router.
Package gorillamux implements a router.
legacy
Package legacy implements a router.
Package legacy implements a router.
legacy/pathpattern
Package pathpattern implements path matching.
Package pathpattern implements path matching.