{{ .Error }}
-- In {{ .FilePath }}:{{ .Line }}
- - -
- {{ range $lineNumber, $line := .Lines }}{{ $lineNumber }}{{ end }}
- |
-
- {{ range $lineNumber, $line := .Lines }}{{ $line }}
- |
-
{{ .Stack }}
- Method: {{ .Method }}
-
+
+
+[![GoDoc Widget]][GoDoc]
+
+`chi` is a lightweight, idiomatic and composable router for building Go HTTP services. It's
+especially good at helping you write large REST API services that are kept maintainable as your
+project grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to
+handle signaling, cancelation and request-scoped values across a handler chain.
+
+The focus of the project has been to seek out an elegant and comfortable design for writing
+REST API servers, written during the development of the Pressly API service that powers our
+public API service, which in turn powers all of our client-side applications.
+
+The key considerations of chi's design are: project structure, maintainability, standard http
+handlers (stdlib-only), developer productivity, and deconstructing a large system into many small
+parts. The core router `github.com/go-chi/chi` is quite small (less than 1000 LOC), but we've also
+included some useful/optional subpackages: [middleware](/middleware), [render](https://github.com/go-chi/render)
+and [docgen](https://github.com/go-chi/docgen). We hope you enjoy it too!
+
+## Install
+
+`go get -u github.com/go-chi/chi/v5`
+
+
+## Features
+
+* **Lightweight** - cloc'd in ~1000 LOC for the chi router
+* **Fast** - yes, see [benchmarks](#benchmarks)
+* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compatible with `net/http`
+* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and sub-router mounting
+* **Context control** - built on new `context` package, providing value chaining, cancellations and timeouts
+* **Robust** - in production at Pressly, Cloudflare, Heroku, 99Designs, and many others (see [discussion](https://github.com/go-chi/chi/issues/91))
+* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown
+* **Go.mod support** - as of v5, go.mod support (see [CHANGELOG](https://github.com/go-chi/chi/blob/master/CHANGELOG.md))
+* **No external dependencies** - plain ol' Go stdlib + net/http
+
+
+## Examples
+
+See [_examples/](https://github.com/go-chi/chi/blob/master/_examples/) for a variety of examples.
+
+
+**As easy as:**
+
+```go
+package main
+
+import (
+ "net/http"
+
+ "github.com/go-chi/chi/v5"
+ "github.com/go-chi/chi/v5/middleware"
+)
+
+func main() {
+ r := chi.NewRouter()
+ r.Use(middleware.Logger)
+ r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("welcome"))
+ })
+ http.ListenAndServe(":3000", r)
+}
+```
+
+**REST Preview:**
+
+Here is a little preview of how routing looks like with chi. Also take a look at the generated routing docs
+in JSON ([routes.json](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.json)) and in
+Markdown ([routes.md](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.md)).
+
+I highly recommend reading the source of the [examples](https://github.com/go-chi/chi/blob/master/_examples/) listed
+above, they will show you all the features of chi and serve as a good form of documentation.
+
+```go
+import (
+ //...
+ "context"
+ "github.com/go-chi/chi/v5"
+ "github.com/go-chi/chi/v5/middleware"
+)
+
+func main() {
+ r := chi.NewRouter()
+
+ // A good base middleware stack
+ r.Use(middleware.RequestID)
+ r.Use(middleware.RealIP)
+ r.Use(middleware.Logger)
+ r.Use(middleware.Recoverer)
+
+ // Set a timeout value on the request context (ctx), that will signal
+ // through ctx.Done() that the request has timed out and further
+ // processing should be stopped.
+ r.Use(middleware.Timeout(60 * time.Second))
+
+ r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("hi"))
+ })
+
+ // RESTy routes for "articles" resource
+ r.Route("/articles", func(r chi.Router) {
+ r.With(paginate).Get("/", listArticles) // GET /articles
+ r.With(paginate).Get("/{month}-{day}-{year}", listArticlesByDate) // GET /articles/01-16-2017
+
+ r.Post("/", createArticle) // POST /articles
+ r.Get("/search", searchArticles) // GET /articles/search
+
+ // Regexp url parameters:
+ r.Get("/{articleSlug:[a-z-]+}", getArticleBySlug) // GET /articles/home-is-toronto
+
+ // Subrouters:
+ r.Route("/{articleID}", func(r chi.Router) {
+ r.Use(ArticleCtx)
+ r.Get("/", getArticle) // GET /articles/123
+ r.Put("/", updateArticle) // PUT /articles/123
+ r.Delete("/", deleteArticle) // DELETE /articles/123
+ })
+ })
+
+ // Mount the admin sub-router
+ r.Mount("/admin", adminRouter())
+
+ http.ListenAndServe(":3333", r)
+}
+
+func ArticleCtx(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ articleID := chi.URLParam(r, "articleID")
+ article, err := dbGetArticle(articleID)
+ if err != nil {
+ http.Error(w, http.StatusText(404), 404)
+ return
+ }
+ ctx := context.WithValue(r.Context(), "article", article)
+ next.ServeHTTP(w, r.WithContext(ctx))
+ })
+}
+
+func getArticle(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+ article, ok := ctx.Value("article").(*Article)
+ if !ok {
+ http.Error(w, http.StatusText(422), 422)
+ return
+ }
+ w.Write([]byte(fmt.Sprintf("title:%s", article.Title)))
+}
+
+// A completely separate router for administrator routes
+func adminRouter() http.Handler {
+ r := chi.NewRouter()
+ r.Use(AdminOnly)
+ r.Get("/", adminIndex)
+ r.Get("/accounts", adminListAccounts)
+ return r
+}
+
+func AdminOnly(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+ perm, ok := ctx.Value("acl.permission").(YourPermissionType)
+ if !ok || !perm.IsAdmin() {
+ http.Error(w, http.StatusText(403), 403)
+ return
+ }
+ next.ServeHTTP(w, r)
+ })
+}
+```
+
+
+## Router interface
+
+chi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree).
+The router is fully compatible with `net/http`.
+
+Built on top of the tree is the `Router` interface:
+
+```go
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+ http.Handler
+ Routes
+
+ // Use appends one or more middlewares onto the Router stack.
+ Use(middlewares ...func(http.Handler) http.Handler)
+
+ // With adds inline middlewares for an endpoint handler.
+ With(middlewares ...func(http.Handler) http.Handler) Router
+
+ // Group adds a new inline-Router along the current routing
+ // path, with a fresh middleware stack for the inline-Router.
+ Group(fn func(r Router)) Router
+
+ // Route mounts a sub-Router along a `pattern`` string.
+ Route(pattern string, fn func(r Router)) Router
+
+ // Mount attaches another http.Handler along ./pattern/*
+ Mount(pattern string, h http.Handler)
+
+ // Handle and HandleFunc adds routes for `pattern` that matches
+ // all HTTP methods.
+ Handle(pattern string, h http.Handler)
+ HandleFunc(pattern string, h http.HandlerFunc)
+
+ // Method and MethodFunc adds routes for `pattern` that matches
+ // the `method` HTTP method.
+ Method(method, pattern string, h http.Handler)
+ MethodFunc(method, pattern string, h http.HandlerFunc)
+
+ // HTTP-method routing along `pattern`
+ Connect(pattern string, h http.HandlerFunc)
+ Delete(pattern string, h http.HandlerFunc)
+ Get(pattern string, h http.HandlerFunc)
+ Head(pattern string, h http.HandlerFunc)
+ Options(pattern string, h http.HandlerFunc)
+ Patch(pattern string, h http.HandlerFunc)
+ Post(pattern string, h http.HandlerFunc)
+ Put(pattern string, h http.HandlerFunc)
+ Trace(pattern string, h http.HandlerFunc)
+
+ // NotFound defines a handler to respond whenever a route could
+ // not be found.
+ NotFound(h http.HandlerFunc)
+
+ // MethodNotAllowed defines a handler to respond whenever a method is
+ // not allowed.
+ MethodNotAllowed(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the github.com/go-chi/docgen package to generate documentation for Routers.
+type Routes interface {
+ // Routes returns the routing tree in an easily traversable structure.
+ Routes() []Route
+
+ // Middlewares returns the list of middlewares in use by the router.
+ Middlewares() Middlewares
+
+ // Match searches the routing tree for a handler that matches
+ // the method/path - similar to routing a http request, but without
+ // executing the handler thereafter.
+ Match(rctx *Context, method, path string) bool
+}
+```
+
+Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern
+supports named params (ie. `/users/{userID}`) and wildcards (ie. `/admin/*`). URL parameters
+can be fetched at runtime by calling `chi.URLParam(r, "userID")` for named parameters
+and `chi.URLParam(r, "*")` for a wildcard parameter.
+
+
+### Middleware handlers
+
+chi's middlewares are just stdlib net/http middleware handlers. There is nothing special
+about them, which means the router and all the tooling is designed to be compatible and
+friendly with any middleware in the community. This offers much better extensibility and reuse
+of packages and is at the heart of chi's purpose.
+
+Here is an example of a standard net/http middleware where we assign a context key `"user"`
+the value of `"123"`. This middleware sets a hypothetical user identifier on the request
+context and calls the next handler in the chain.
+
+```go
+// HTTP middleware setting a value on the request context
+func MyMiddleware(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // create new context from `r` request context, and assign key `"user"`
+ // to value of `"123"`
+ ctx := context.WithValue(r.Context(), "user", "123")
+
+ // call the next handler in the chain, passing the response writer and
+ // the updated request object with the new context value.
+ //
+ // note: context.Context values are nested, so any previously set
+ // values will be accessible as well, and the new `"user"` key
+ // will be accessible from this point forward.
+ next.ServeHTTP(w, r.WithContext(ctx))
+ })
+}
+```
+
+
+### Request handlers
+
+chi uses standard net/http request handlers. This little snippet is an example of a http.Handler
+func that reads a user identifier from the request context - hypothetically, identifying
+the user sending an authenticated request, validated+set by a previous middleware handler.
+
+```go
+// HTTP handler accessing data from the request context.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+ // here we read from the request context and fetch out `"user"` key set in
+ // the MyMiddleware example above.
+ user := r.Context().Value("user").(string)
+
+ // respond to the client
+ w.Write([]byte(fmt.Sprintf("hi %s", user)))
+}
+```
+
+
+### URL parameters
+
+chi's router parses and stores URL parameters right onto the request context. Here is
+an example of how to access URL params in your net/http handlers. And of course, middlewares
+are able to access the same information.
+
+```go
+// HTTP handler accessing the url routing parameters.
+func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
+ // fetch the url parameter `"userID"` from the request of a matching
+ // routing pattern. An example routing pattern could be: /users/{userID}
+ userID := chi.URLParam(r, "userID")
+
+ // fetch `"key"` from the request context
+ ctx := r.Context()
+ key := ctx.Value("key").(string)
+
+ // respond to the client
+ w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key)))
+}
+```
+
+
+## Middlewares
+
+chi comes equipped with an optional `middleware` package, providing a suite of standard
+`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible
+with `net/http` can be used with chi's mux.
+
+### Core middlewares
+
+----------------------------------------------------------------------------------------------------
+| chi/middleware Handler | description |
+| :--------------------- | :---------------------------------------------------------------------- |
+| [AllowContentEncoding] | Enforces a whitelist of request Content-Encoding headers |
+| [AllowContentType] | Explicit whitelist of accepted request Content-Types |
+| [BasicAuth] | Basic HTTP authentication |
+| [Compress] | Gzip compression for clients that accept compressed responses |
+| [ContentCharset] | Ensure charset for Content-Type request headers |
+| [CleanPath] | Clean double slashes from request path |
+| [GetHead] | Automatically route undefined HEAD requests to GET handlers |
+| [Heartbeat] | Monitoring endpoint to check the servers pulse |
+| [Logger] | Logs the start and end of each request with the elapsed processing time |
+| [NoCache] | Sets response headers to prevent clients from caching |
+| [Profiler] | Easily attach net/http/pprof to your routers |
+| [RealIP] | Sets a http.Request's RemoteAddr to either X-Real-IP or X-Forwarded-For |
+| [Recoverer] | Gracefully absorb panics and prints the stack trace |
+| [RequestID] | Injects a request ID into the context of each request |
+| [RedirectSlashes] | Redirect slashes on routing paths |
+| [RouteHeaders] | Route handling for request headers |
+| [SetHeader] | Short-hand middleware to set a response header key/value |
+| [StripSlashes] | Strip slashes on routing paths |
+| [Throttle] | Puts a ceiling on the number of concurrent requests |
+| [Timeout] | Signals to the request context when the timeout deadline is reached |
+| [URLFormat] | Parse extension from url and put it on request context |
+| [WithValue] | Short-hand middleware to set a key/value on the request context |
+----------------------------------------------------------------------------------------------------
+
+[AllowContentEncoding]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentEncoding
+[AllowContentType]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentType
+[BasicAuth]: https://pkg.go.dev/github.com/go-chi/chi/middleware#BasicAuth
+[Compress]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compress
+[ContentCharset]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ContentCharset
+[CleanPath]: https://pkg.go.dev/github.com/go-chi/chi/middleware#CleanPath
+[GetHead]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetHead
+[GetReqID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetReqID
+[Heartbeat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Heartbeat
+[Logger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Logger
+[NoCache]: https://pkg.go.dev/github.com/go-chi/chi/middleware#NoCache
+[Profiler]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Profiler
+[RealIP]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RealIP
+[Recoverer]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Recoverer
+[RedirectSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RedirectSlashes
+[RequestLogger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestLogger
+[RequestID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestID
+[RouteHeaders]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RouteHeaders
+[SetHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#SetHeader
+[StripSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#StripSlashes
+[Throttle]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Throttle
+[ThrottleBacklog]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleBacklog
+[ThrottleWithOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleWithOpts
+[Timeout]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Timeout
+[URLFormat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#URLFormat
+[WithLogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithLogEntry
+[WithValue]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithValue
+[Compressor]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compressor
+[DefaultLogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#DefaultLogFormatter
+[EncoderFunc]: https://pkg.go.dev/github.com/go-chi/chi/middleware#EncoderFunc
+[HeaderRoute]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRoute
+[HeaderRouter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRouter
+[LogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogEntry
+[LogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogFormatter
+[LoggerInterface]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LoggerInterface
+[ThrottleOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleOpts
+[WrapResponseWriter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WrapResponseWriter
+
+### Extra middlewares & packages
+
+Please see https://github.com/go-chi for additional packages.
+
+--------------------------------------------------------------------------------------------------------------------
+| package | description |
+|:---------------------------------------------------|:-------------------------------------------------------------
+| [cors](https://github.com/go-chi/cors) | Cross-origin resource sharing (CORS) |
+| [docgen](https://github.com/go-chi/docgen) | Print chi.Router routes at runtime |
+| [jwtauth](https://github.com/go-chi/jwtauth) | JWT authentication |
+| [hostrouter](https://github.com/go-chi/hostrouter) | Domain/host based request routing |
+| [httplog](https://github.com/go-chi/httplog) | Small but powerful structured HTTP request logging |
+| [httprate](https://github.com/go-chi/httprate) | HTTP request rate limiter |
+| [httptracer](https://github.com/go-chi/httptracer) | HTTP request performance tracing library |
+| [httpvcr](https://github.com/go-chi/httpvcr) | Write deterministic tests for external sources |
+| [stampede](https://github.com/go-chi/stampede) | HTTP request coalescer |
+--------------------------------------------------------------------------------------------------------------------
+
+
+## context?
+
+`context` is a tiny pkg that provides simple interface to signal context across call stacks
+and goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani)
+and is available in stdlib since go1.7.
+
+Learn more at https://blog.golang.org/context
+
+and..
+* Docs: https://golang.org/pkg/context
+* Source: https://github.com/golang/go/tree/master/src/context
+
+
+## Benchmarks
+
+The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark
+
+Results as of Nov 29, 2020 with Go 1.15.5 on Linux AMD 3950x
+
+```shell
+BenchmarkChi_Param 3075895 384 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_Param5 2116603 566 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_Param20 964117 1227 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_ParamWrite 2863413 420 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GithubStatic 3045488 395 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GithubParam 2204115 540 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GithubAll 10000 113811 ns/op 81203 B/op 406 allocs/op
+BenchmarkChi_GPlusStatic 3337485 359 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GPlusParam 2825853 423 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GPlus2Params 2471697 483 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_GPlusAll 194220 5950 ns/op 5200 B/op 26 allocs/op
+BenchmarkChi_ParseStatic 3365324 356 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_ParseParam 2976614 404 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_Parse2Params 2638084 439 ns/op 400 B/op 2 allocs/op
+BenchmarkChi_ParseAll 109567 11295 ns/op 10400 B/op 52 allocs/op
+BenchmarkChi_StaticAll 16846 71308 ns/op 62802 B/op 314 allocs/op
+```
+
+Comparison with other routers: https://gist.github.com/pkieltyka/123032f12052520aaccab752bd3e78cc
+
+NOTE: the allocs in the benchmark above are from the calls to http.Request's
+`WithContext(context.Context)` method that clones the http.Request, sets the `Context()`
+on the duplicated (alloc'd) request and returns it the new request object. This is just
+how setting context on a request in Go works.
+
+
+## Credits
+
+* Carl Jackson for https://github.com/zenazn/goji
+ * Parts of chi's thinking comes from goji, and chi's middleware package
+ sources from goji.
+* Armon Dadgar for https://github.com/armon/go-radix
+* Contributions: [@VojtechVitek](https://github.com/VojtechVitek)
+
+We'll be more than happy to see [your contributions](./CONTRIBUTING.md)!
+
+
+## Beyond REST
+
+chi is just a http router that lets you decompose request handling into many smaller layers.
+Many companies use chi to write REST services for their public APIs. But, REST is just a convention
+for managing state via HTTP, and there's a lot of other pieces required to write a complete client-server
+system or network of microservices.
+
+Looking beyond REST, I also recommend some newer works in the field:
+* [webrpc](https://github.com/webrpc/webrpc) - Web-focused RPC client+server framework with code-gen
+* [gRPC](https://github.com/grpc/grpc-go) - Google's RPC framework via protobufs
+* [graphql](https://github.com/99designs/gqlgen) - Declarative query language
+* [NATS](https://nats.io) - lightweight pub-sub
+
+
+## License
+
+Copyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka)
+
+Licensed under [MIT License](./LICENSE)
+
+[GoDoc]: https://pkg.go.dev/github.com/go-chi/chi?tab=versions
+[GoDoc Widget]: https://godoc.org/github.com/go-chi/chi?status.svg
+[Travis]: https://travis-ci.org/go-chi/chi
+[Travis Widget]: https://travis-ci.org/go-chi/chi.svg?branch=master
diff --git a/vendor/github.com/go-chi/chi/v5/chain.go b/vendor/github.com/go-chi/chi/v5/chain.go
new file mode 100644
index 0000000000..a2278414f4
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/chain.go
@@ -0,0 +1,49 @@
+package chi
+
+import "net/http"
+
+// Chain returns a Middlewares type from a slice of middleware handlers.
+func Chain(middlewares ...func(http.Handler) http.Handler) Middlewares {
+ return Middlewares(middlewares)
+}
+
+// Handler builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) Handler(h http.Handler) http.Handler {
+ return &ChainHandler{h, chain(mws, h), mws}
+}
+
+// HandlerFunc builds and returns a http.Handler from the chain of middlewares,
+// with `h http.Handler` as the final handler.
+func (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler {
+ return &ChainHandler{h, chain(mws, h), mws}
+}
+
+// ChainHandler is a http.Handler with support for handler composition and
+// execution.
+type ChainHandler struct {
+ Endpoint http.Handler
+ chain http.Handler
+ Middlewares Middlewares
+}
+
+func (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ c.chain.ServeHTTP(w, r)
+}
+
+// chain builds a http.Handler composed of an inline middleware stack and endpoint
+// handler in the order they are passed.
+func chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler {
+ // Return ahead of time if there aren't any middlewares for the chain
+ if len(middlewares) == 0 {
+ return endpoint
+ }
+
+ // Wrap the end handler with the middleware chain
+ h := middlewares[len(middlewares)-1](endpoint)
+ for i := len(middlewares) - 2; i >= 0; i-- {
+ h = middlewares[i](h)
+ }
+
+ return h
+}
diff --git a/vendor/github.com/go-chi/chi/v5/chi.go b/vendor/github.com/go-chi/chi/v5/chi.go
new file mode 100644
index 0000000000..a1691bbeb1
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/chi.go
@@ -0,0 +1,134 @@
+// Package chi is a small, idiomatic and composable router for building HTTP services.
+//
+// chi requires Go 1.14 or newer.
+//
+// Example:
+//
+// package main
+//
+// import (
+// "net/http"
+//
+// "github.com/go-chi/chi/v5"
+// "github.com/go-chi/chi/v5/middleware"
+// )
+//
+// func main() {
+// r := chi.NewRouter()
+// r.Use(middleware.Logger)
+// r.Use(middleware.Recoverer)
+//
+// r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+// w.Write([]byte("root."))
+// })
+//
+// http.ListenAndServe(":3333", r)
+// }
+//
+// See github.com/go-chi/chi/_examples/ for more in-depth examples.
+//
+// URL patterns allow for easy matching of path components in HTTP
+// requests. The matching components can then be accessed using
+// chi.URLParam(). All patterns must begin with a slash.
+//
+// A simple named placeholder {name} matches any sequence of characters
+// up to the next / or the end of the URL. Trailing slashes on paths must
+// be handled explicitly.
+//
+// A placeholder with a name followed by a colon allows a regular
+// expression match, for example {number:\\d+}. The regular expression
+// syntax is Go's normal regexp RE2 syntax, except that regular expressions
+// including { or } are not supported, and / will never be
+// matched. An anonymous regexp pattern is allowed, using an empty string
+// before the colon in the placeholder, such as {:\\d+}
+//
+// The special placeholder of asterisk matches the rest of the requested
+// URL. Any trailing characters in the pattern are ignored. This is the only
+// placeholder which will match / characters.
+//
+// Examples:
+//
+// "/user/{name}" matches "/user/jsmith" but not "/user/jsmith/info" or "/user/jsmith/"
+// "/user/{name}/info" matches "/user/jsmith/info"
+// "/page/*" matches "/page/intro/latest"
+// "/page/{other}/index" also matches "/page/intro/latest"
+// "/date/{yyyy:\\d\\d\\d\\d}/{mm:\\d\\d}/{dd:\\d\\d}" matches "/date/2017/04/01"
+package chi
+
+import "net/http"
+
+// NewRouter returns a new Mux object that implements the Router interface.
+func NewRouter() *Mux {
+ return NewMux()
+}
+
+// Router consisting of the core routing methods used by chi's Mux,
+// using only the standard net/http.
+type Router interface {
+ http.Handler
+ Routes
+
+ // Use appends one or more middlewares onto the Router stack.
+ Use(middlewares ...func(http.Handler) http.Handler)
+
+ // With adds inline middlewares for an endpoint handler.
+ With(middlewares ...func(http.Handler) http.Handler) Router
+
+ // Group adds a new inline-Router along the current routing
+ // path, with a fresh middleware stack for the inline-Router.
+ Group(fn func(r Router)) Router
+
+ // Route mounts a sub-Router along a `pattern`` string.
+ Route(pattern string, fn func(r Router)) Router
+
+ // Mount attaches another http.Handler along ./pattern/*
+ Mount(pattern string, h http.Handler)
+
+ // Handle and HandleFunc adds routes for `pattern` that matches
+ // all HTTP methods.
+ Handle(pattern string, h http.Handler)
+ HandleFunc(pattern string, h http.HandlerFunc)
+
+ // Method and MethodFunc adds routes for `pattern` that matches
+ // the `method` HTTP method.
+ Method(method, pattern string, h http.Handler)
+ MethodFunc(method, pattern string, h http.HandlerFunc)
+
+ // HTTP-method routing along `pattern`
+ Connect(pattern string, h http.HandlerFunc)
+ Delete(pattern string, h http.HandlerFunc)
+ Get(pattern string, h http.HandlerFunc)
+ Head(pattern string, h http.HandlerFunc)
+ Options(pattern string, h http.HandlerFunc)
+ Patch(pattern string, h http.HandlerFunc)
+ Post(pattern string, h http.HandlerFunc)
+ Put(pattern string, h http.HandlerFunc)
+ Trace(pattern string, h http.HandlerFunc)
+
+ // NotFound defines a handler to respond whenever a route could
+ // not be found.
+ NotFound(h http.HandlerFunc)
+
+ // MethodNotAllowed defines a handler to respond whenever a method is
+ // not allowed.
+ MethodNotAllowed(h http.HandlerFunc)
+}
+
+// Routes interface adds two methods for router traversal, which is also
+// used by the `docgen` subpackage to generation documentation for Routers.
+type Routes interface {
+ // Routes returns the routing tree in an easily traversable structure.
+ Routes() []Route
+
+ // Middlewares returns the list of middlewares in use by the router.
+ Middlewares() Middlewares
+
+ // Match searches the routing tree for a handler that matches
+ // the method/path - similar to routing a http request, but without
+ // executing the handler thereafter.
+ Match(rctx *Context, method, path string) bool
+}
+
+// Middlewares type is a slice of standard middleware handlers with methods
+// to compose middleware chains and http.Handler's.
+type Middlewares []func(http.Handler) http.Handler
diff --git a/vendor/github.com/go-chi/chi/v5/context.go b/vendor/github.com/go-chi/chi/v5/context.go
new file mode 100644
index 0000000000..88f8e221a1
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/context.go
@@ -0,0 +1,160 @@
+package chi
+
+import (
+ "context"
+ "net/http"
+ "strings"
+)
+
+// URLParam returns the url parameter from a http.Request object.
+func URLParam(r *http.Request, key string) string {
+ if rctx := RouteContext(r.Context()); rctx != nil {
+ return rctx.URLParam(key)
+ }
+ return ""
+}
+
+// URLParamFromCtx returns the url parameter from a http.Request Context.
+func URLParamFromCtx(ctx context.Context, key string) string {
+ if rctx := RouteContext(ctx); rctx != nil {
+ return rctx.URLParam(key)
+ }
+ return ""
+}
+
+// RouteContext returns chi's routing Context object from a
+// http.Request Context.
+func RouteContext(ctx context.Context) *Context {
+ val, _ := ctx.Value(RouteCtxKey).(*Context)
+ return val
+}
+
+// NewRouteContext returns a new routing Context object.
+func NewRouteContext() *Context {
+ return &Context{}
+}
+
+var (
+ // RouteCtxKey is the context.Context key to store the request context.
+ RouteCtxKey = &contextKey{"RouteContext"}
+)
+
+// Context is the default routing context set on the root node of a
+// request context to track route patterns, URL parameters and
+// an optional routing path.
+type Context struct {
+ Routes Routes
+
+ // parentCtx is the parent of this one, for using Context as a
+ // context.Context directly. This is an optimization that saves
+ // 1 allocation.
+ parentCtx context.Context
+
+ // Routing path/method override used during the route search.
+ // See Mux#routeHTTP method.
+ RoutePath string
+ RouteMethod string
+
+ // URLParams are the stack of routeParams captured during the
+ // routing lifecycle across a stack of sub-routers.
+ URLParams RouteParams
+
+ // Route parameters matched for the current sub-router. It is
+ // intentionally unexported so it cant be tampered.
+ routeParams RouteParams
+
+ // The endpoint routing pattern that matched the request URI path
+ // or `RoutePath` of the current sub-router. This value will update
+ // during the lifecycle of a request passing through a stack of
+ // sub-routers.
+ routePattern string
+
+ // Routing pattern stack throughout the lifecycle of the request,
+ // across all connected routers. It is a record of all matching
+ // patterns across a stack of sub-routers.
+ RoutePatterns []string
+
+ // methodNotAllowed hint
+ methodNotAllowed bool
+ methodsAllowed []methodTyp // allowed methods in case of a 405
+}
+
+// Reset a routing context to its initial state.
+func (x *Context) Reset() {
+ x.Routes = nil
+ x.RoutePath = ""
+ x.RouteMethod = ""
+ x.RoutePatterns = x.RoutePatterns[:0]
+ x.URLParams.Keys = x.URLParams.Keys[:0]
+ x.URLParams.Values = x.URLParams.Values[:0]
+
+ x.routePattern = ""
+ x.routeParams.Keys = x.routeParams.Keys[:0]
+ x.routeParams.Values = x.routeParams.Values[:0]
+ x.methodNotAllowed = false
+ x.parentCtx = nil
+}
+
+// URLParam returns the corresponding URL parameter value from the request
+// routing context.
+func (x *Context) URLParam(key string) string {
+ for k := len(x.URLParams.Keys) - 1; k >= 0; k-- {
+ if x.URLParams.Keys[k] == key {
+ return x.URLParams.Values[k]
+ }
+ }
+ return ""
+}
+
+// RoutePattern builds the routing pattern string for the particular
+// request, at the particular point during routing. This means, the value
+// will change throughout the execution of a request in a router. That is
+// why its advised to only use this value after calling the next handler.
+//
+// For example,
+//
+// func Instrument(next http.Handler) http.Handler {
+// return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+// next.ServeHTTP(w, r)
+// routePattern := chi.RouteContext(r.Context()).RoutePattern()
+// measure(w, r, routePattern)
+// })
+// }
+func (x *Context) RoutePattern() string {
+ routePattern := strings.Join(x.RoutePatterns, "")
+ routePattern = replaceWildcards(routePattern)
+ routePattern = strings.TrimSuffix(routePattern, "//")
+ routePattern = strings.TrimSuffix(routePattern, "/")
+ return routePattern
+}
+
+// replaceWildcards takes a route pattern and recursively replaces all
+// occurrences of "/*/" to "/".
+func replaceWildcards(p string) string {
+ if strings.Contains(p, "/*/") {
+ return replaceWildcards(strings.Replace(p, "/*/", "/", -1))
+ }
+ return p
+}
+
+// RouteParams is a structure to track URL routing parameters efficiently.
+type RouteParams struct {
+ Keys, Values []string
+}
+
+// Add will append a URL parameter to the end of the route param
+func (s *RouteParams) Add(key, value string) {
+ s.Keys = append(s.Keys, key)
+ s.Values = append(s.Values, value)
+}
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation. This technique
+// for defining context keys was copied from Go 1.7's new use of context in net/http.
+type contextKey struct {
+ name string
+}
+
+func (k *contextKey) String() string {
+ return "chi context value " + k.name
+}
diff --git a/vendor/github.com/go-chi/chi/v5/mux.go b/vendor/github.com/go-chi/chi/v5/mux.go
new file mode 100644
index 0000000000..977aa52dd1
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/mux.go
@@ -0,0 +1,493 @@
+package chi
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "strings"
+ "sync"
+)
+
+var _ Router = &Mux{}
+
+// Mux is a simple HTTP route multiplexer that parses a request path,
+// records any URL params, and executes an end handler. It implements
+// the http.Handler interface and is friendly with the standard library.
+//
+// Mux is designed to be fast, minimal and offer a powerful API for building
+// modular and composable HTTP services with a large set of handlers. It's
+// particularly useful for writing large REST API services that break a handler
+// into many smaller parts composed of middlewares and end handlers.
+type Mux struct {
+ // The computed mux handler made of the chained middleware stack and
+ // the tree router
+ handler http.Handler
+
+ // The radix trie router
+ tree *node
+
+ // Custom method not allowed handler
+ methodNotAllowedHandler http.HandlerFunc
+
+ // A reference to the parent mux used by subrouters when mounting
+ // to a parent mux
+ parent *Mux
+
+ // Routing context pool
+ pool *sync.Pool
+
+ // Custom route not found handler
+ notFoundHandler http.HandlerFunc
+
+ // The middleware stack
+ middlewares []func(http.Handler) http.Handler
+
+ // Controls the behaviour of middleware chain generation when a mux
+ // is registered as an inline group inside another mux.
+ inline bool
+}
+
+// NewMux returns a newly initialized Mux object that implements the Router
+// interface.
+func NewMux() *Mux {
+ mux := &Mux{tree: &node{}, pool: &sync.Pool{}}
+ mux.pool.New = func() interface{} {
+ return NewRouteContext()
+ }
+ return mux
+}
+
+// ServeHTTP is the single method of the http.Handler interface that makes
+// Mux interoperable with the standard library. It uses a sync.Pool to get and
+// reuse routing contexts for each request.
+func (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Ensure the mux has some routes defined on the mux
+ if mx.handler == nil {
+ mx.NotFoundHandler().ServeHTTP(w, r)
+ return
+ }
+
+ // Check if a routing context already exists from a parent router.
+ rctx, _ := r.Context().Value(RouteCtxKey).(*Context)
+ if rctx != nil {
+ mx.handler.ServeHTTP(w, r)
+ return
+ }
+
+ // Fetch a RouteContext object from the sync pool, and call the computed
+ // mx.handler that is comprised of mx.middlewares + mx.routeHTTP.
+ // Once the request is finished, reset the routing context and put it back
+ // into the pool for reuse from another request.
+ rctx = mx.pool.Get().(*Context)
+ rctx.Reset()
+ rctx.Routes = mx
+ rctx.parentCtx = r.Context()
+
+ // NOTE: r.WithContext() causes 2 allocations and context.WithValue() causes 1 allocation
+ r = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx))
+
+ // Serve the request and once its done, put the request context back in the sync pool
+ mx.handler.ServeHTTP(w, r)
+ mx.pool.Put(rctx)
+}
+
+// Use appends a middleware handler to the Mux middleware stack.
+//
+// The middleware stack for any Mux will execute before searching for a matching
+// route to a specific handler, which provides opportunity to respond early,
+// change the course of the request execution, or set request-scoped values for
+// the next http.Handler.
+func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
+ if mx.handler != nil {
+ panic("chi: all middlewares must be defined before routes on a mux")
+ }
+ mx.middlewares = append(mx.middlewares, middlewares...)
+}
+
+// Handle adds the route `pattern` that matches any http method to
+// execute the `handler` http.Handler.
+func (mx *Mux) Handle(pattern string, handler http.Handler) {
+ mx.handle(mALL, pattern, handler)
+}
+
+// HandleFunc adds the route `pattern` that matches any http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mALL, pattern, handlerFn)
+}
+
+// Method adds the route `pattern` that matches `method` http method to
+// execute the `handler` http.Handler.
+func (mx *Mux) Method(method, pattern string, handler http.Handler) {
+ m, ok := methodMap[strings.ToUpper(method)]
+ if !ok {
+ panic(fmt.Sprintf("chi: '%s' http method is not supported.", method))
+ }
+ mx.handle(m, pattern, handler)
+}
+
+// MethodFunc adds the route `pattern` that matches `method` http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) MethodFunc(method, pattern string, handlerFn http.HandlerFunc) {
+ mx.Method(method, pattern, handlerFn)
+}
+
+// Connect adds the route `pattern` that matches a CONNECT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mCONNECT, pattern, handlerFn)
+}
+
+// Delete adds the route `pattern` that matches a DELETE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mDELETE, pattern, handlerFn)
+}
+
+// Get adds the route `pattern` that matches a GET http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mGET, pattern, handlerFn)
+}
+
+// Head adds the route `pattern` that matches a HEAD http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mHEAD, pattern, handlerFn)
+}
+
+// Options adds the route `pattern` that matches an OPTIONS http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mOPTIONS, pattern, handlerFn)
+}
+
+// Patch adds the route `pattern` that matches a PATCH http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mPATCH, pattern, handlerFn)
+}
+
+// Post adds the route `pattern` that matches a POST http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mPOST, pattern, handlerFn)
+}
+
+// Put adds the route `pattern` that matches a PUT http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mPUT, pattern, handlerFn)
+}
+
+// Trace adds the route `pattern` that matches a TRACE http method to
+// execute the `handlerFn` http.HandlerFunc.
+func (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) {
+ mx.handle(mTRACE, pattern, handlerFn)
+}
+
+// NotFound sets a custom http.HandlerFunc for routing paths that could
+// not be found. The default 404 handler is `http.NotFound`.
+func (mx *Mux) NotFound(handlerFn http.HandlerFunc) {
+ // Build NotFound handler chain
+ m := mx
+ hFn := handlerFn
+ if mx.inline && mx.parent != nil {
+ m = mx.parent
+ hFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP
+ }
+
+ // Update the notFoundHandler from this point forward
+ m.notFoundHandler = hFn
+ m.updateSubRoutes(func(subMux *Mux) {
+ if subMux.notFoundHandler == nil {
+ subMux.NotFound(hFn)
+ }
+ })
+}
+
+// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the
+// method is unresolved. The default handler returns a 405 with an empty body.
+func (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) {
+ // Build MethodNotAllowed handler chain
+ m := mx
+ hFn := handlerFn
+ if mx.inline && mx.parent != nil {
+ m = mx.parent
+ hFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP
+ }
+
+ // Update the methodNotAllowedHandler from this point forward
+ m.methodNotAllowedHandler = hFn
+ m.updateSubRoutes(func(subMux *Mux) {
+ if subMux.methodNotAllowedHandler == nil {
+ subMux.MethodNotAllowed(hFn)
+ }
+ })
+}
+
+// With adds inline middlewares for an endpoint handler.
+func (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router {
+ // Similarly as in handle(), we must build the mux handler once additional
+ // middleware registration isn't allowed for this stack, like now.
+ if !mx.inline && mx.handler == nil {
+ mx.updateRouteHandler()
+ }
+
+ // Copy middlewares from parent inline muxs
+ var mws Middlewares
+ if mx.inline {
+ mws = make(Middlewares, len(mx.middlewares))
+ copy(mws, mx.middlewares)
+ }
+ mws = append(mws, middlewares...)
+
+ im := &Mux{
+ pool: mx.pool, inline: true, parent: mx, tree: mx.tree, middlewares: mws,
+ notFoundHandler: mx.notFoundHandler, methodNotAllowedHandler: mx.methodNotAllowedHandler,
+ }
+
+ return im
+}
+
+// Group creates a new inline-Mux with a fresh middleware stack. It's useful
+// for a group of handlers along the same routing path that use an additional
+// set of middlewares. See _examples/.
+func (mx *Mux) Group(fn func(r Router)) Router {
+ im := mx.With().(*Mux)
+ if fn != nil {
+ fn(im)
+ }
+ return im
+}
+
+// Route creates a new Mux with a fresh middleware stack and mounts it
+// along the `pattern` as a subrouter. Effectively, this is a short-hand
+// call to Mount. See _examples/.
+func (mx *Mux) Route(pattern string, fn func(r Router)) Router {
+ if fn == nil {
+ panic(fmt.Sprintf("chi: attempting to Route() a nil subrouter on '%s'", pattern))
+ }
+ subRouter := NewRouter()
+ fn(subRouter)
+ mx.Mount(pattern, subRouter)
+ return subRouter
+}
+
+// Mount attaches another http.Handler or chi Router as a subrouter along a routing
+// path. It's very useful to split up a large API as many independent routers and
+// compose them as a single service using Mount. See _examples/.
+//
+// Note that Mount() simply sets a wildcard along the `pattern` that will continue
+// routing at the `handler`, which in most cases is another chi.Router. As a result,
+// if you define two Mount() routes on the exact same pattern the mount will panic.
+func (mx *Mux) Mount(pattern string, handler http.Handler) {
+ if handler == nil {
+ panic(fmt.Sprintf("chi: attempting to Mount() a nil handler on '%s'", pattern))
+ }
+
+ // Provide runtime safety for ensuring a pattern isn't mounted on an existing
+ // routing pattern.
+ if mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*") {
+ panic(fmt.Sprintf("chi: attempting to Mount() a handler on an existing path, '%s'", pattern))
+ }
+
+ // Assign sub-Router's with the parent not found & method not allowed handler if not specified.
+ subr, ok := handler.(*Mux)
+ if ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil {
+ subr.NotFound(mx.notFoundHandler)
+ }
+ if ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil {
+ subr.MethodNotAllowed(mx.methodNotAllowedHandler)
+ }
+
+ mountHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ rctx := RouteContext(r.Context())
+
+ // shift the url path past the previous subrouter
+ rctx.RoutePath = mx.nextRoutePath(rctx)
+
+ // reset the wildcard URLParam which connects the subrouter
+ n := len(rctx.URLParams.Keys) - 1
+ if n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n {
+ rctx.URLParams.Values[n] = ""
+ }
+
+ handler.ServeHTTP(w, r)
+ })
+
+ if pattern == "" || pattern[len(pattern)-1] != '/' {
+ mx.handle(mALL|mSTUB, pattern, mountHandler)
+ mx.handle(mALL|mSTUB, pattern+"/", mountHandler)
+ pattern += "/"
+ }
+
+ method := mALL
+ subroutes, _ := handler.(Routes)
+ if subroutes != nil {
+ method |= mSTUB
+ }
+ n := mx.handle(method, pattern+"*", mountHandler)
+
+ if subroutes != nil {
+ n.subroutes = subroutes
+ }
+}
+
+// Routes returns a slice of routing information from the tree,
+// useful for traversing available routes of a router.
+func (mx *Mux) Routes() []Route {
+ return mx.tree.routes()
+}
+
+// Middlewares returns a slice of middleware handler functions.
+func (mx *Mux) Middlewares() Middlewares {
+ return mx.middlewares
+}
+
+// Match searches the routing tree for a handler that matches the method/path.
+// It's similar to routing a http request, but without executing the handler
+// thereafter.
+//
+// Note: the *Context state is updated during execution, so manage
+// the state carefully or make a NewRouteContext().
+func (mx *Mux) Match(rctx *Context, method, path string) bool {
+ m, ok := methodMap[method]
+ if !ok {
+ return false
+ }
+
+ node, _, h := mx.tree.FindRoute(rctx, m, path)
+
+ if node != nil && node.subroutes != nil {
+ rctx.RoutePath = mx.nextRoutePath(rctx)
+ return node.subroutes.Match(rctx, method, rctx.RoutePath)
+ }
+
+ return h != nil
+}
+
+// NotFoundHandler returns the default Mux 404 responder whenever a route
+// cannot be found.
+func (mx *Mux) NotFoundHandler() http.HandlerFunc {
+ if mx.notFoundHandler != nil {
+ return mx.notFoundHandler
+ }
+ return http.NotFound
+}
+
+// MethodNotAllowedHandler returns the default Mux 405 responder whenever
+// a method cannot be resolved for a route.
+func (mx *Mux) MethodNotAllowedHandler(methodsAllowed ...methodTyp) http.HandlerFunc {
+ if mx.methodNotAllowedHandler != nil {
+ return mx.methodNotAllowedHandler
+ }
+ return methodNotAllowedHandler(methodsAllowed...)
+}
+
+// handle registers a http.Handler in the routing tree for a particular http method
+// and routing pattern.
+func (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node {
+ if len(pattern) == 0 || pattern[0] != '/' {
+ panic(fmt.Sprintf("chi: routing pattern must begin with '/' in '%s'", pattern))
+ }
+
+ // Build the computed routing handler for this routing pattern.
+ if !mx.inline && mx.handler == nil {
+ mx.updateRouteHandler()
+ }
+
+ // Build endpoint handler with inline middlewares for the route
+ var h http.Handler
+ if mx.inline {
+ mx.handler = http.HandlerFunc(mx.routeHTTP)
+ h = Chain(mx.middlewares...).Handler(handler)
+ } else {
+ h = handler
+ }
+
+ // Add the endpoint to the tree and return the node
+ return mx.tree.InsertRoute(method, pattern, h)
+}
+
+// routeHTTP routes a http.Request through the Mux routing tree to serve
+// the matching handler for a particular http method.
+func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Grab the route context object
+ rctx := r.Context().Value(RouteCtxKey).(*Context)
+
+ // The request routing path
+ routePath := rctx.RoutePath
+ if routePath == "" {
+ if r.URL.RawPath != "" {
+ routePath = r.URL.RawPath
+ } else {
+ routePath = r.URL.Path
+ }
+ if routePath == "" {
+ routePath = "/"
+ }
+ }
+
+ // Check if method is supported by chi
+ if rctx.RouteMethod == "" {
+ rctx.RouteMethod = r.Method
+ }
+ method, ok := methodMap[rctx.RouteMethod]
+ if !ok {
+ mx.MethodNotAllowedHandler().ServeHTTP(w, r)
+ return
+ }
+
+ // Find the route
+ if _, _, h := mx.tree.FindRoute(rctx, method, routePath); h != nil {
+ h.ServeHTTP(w, r)
+ return
+ }
+ if rctx.methodNotAllowed {
+ mx.MethodNotAllowedHandler(rctx.methodsAllowed...).ServeHTTP(w, r)
+ } else {
+ mx.NotFoundHandler().ServeHTTP(w, r)
+ }
+}
+
+func (mx *Mux) nextRoutePath(rctx *Context) string {
+ routePath := "/"
+ nx := len(rctx.routeParams.Keys) - 1 // index of last param in list
+ if nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx {
+ routePath = "/" + rctx.routeParams.Values[nx]
+ }
+ return routePath
+}
+
+// Recursively update data on child routers.
+func (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) {
+ for _, r := range mx.tree.routes() {
+ subMux, ok := r.SubRoutes.(*Mux)
+ if !ok {
+ continue
+ }
+ fn(subMux)
+ }
+}
+
+// updateRouteHandler builds the single mux handler that is a chain of the middleware
+// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this
+// point, no other middlewares can be registered on this Mux's stack. But you can still
+// compose additional middlewares via Group()'s or using a chained middleware handler.
+func (mx *Mux) updateRouteHandler() {
+ mx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP))
+}
+
+// methodNotAllowedHandler is a helper function to respond with a 405,
+// method not allowed. It sets the Allow header with the list of allowed
+// methods for the route.
+func methodNotAllowedHandler(methodsAllowed ...methodTyp) func(w http.ResponseWriter, r *http.Request) {
+ return func(w http.ResponseWriter, r *http.Request) {
+ for _, m := range methodsAllowed {
+ w.Header().Add("Allow", reverseMethodMap[m])
+ }
+ w.WriteHeader(405)
+ w.Write(nil)
+ }
+}
diff --git a/vendor/github.com/go-chi/chi/v5/tree.go b/vendor/github.com/go-chi/chi/v5/tree.go
new file mode 100644
index 0000000000..c7d3bc5704
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/tree.go
@@ -0,0 +1,892 @@
+package chi
+
+// Radix tree implementation below is a based on the original work by
+// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
+// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
+
+import (
+ "fmt"
+ "net/http"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+type methodTyp uint
+
+const (
+ mSTUB methodTyp = 1 << iota
+ mCONNECT
+ mDELETE
+ mGET
+ mHEAD
+ mOPTIONS
+ mPATCH
+ mPOST
+ mPUT
+ mTRACE
+)
+
+var mALL = mCONNECT | mDELETE | mGET | mHEAD |
+ mOPTIONS | mPATCH | mPOST | mPUT | mTRACE
+
+var methodMap = map[string]methodTyp{
+ http.MethodConnect: mCONNECT,
+ http.MethodDelete: mDELETE,
+ http.MethodGet: mGET,
+ http.MethodHead: mHEAD,
+ http.MethodOptions: mOPTIONS,
+ http.MethodPatch: mPATCH,
+ http.MethodPost: mPOST,
+ http.MethodPut: mPUT,
+ http.MethodTrace: mTRACE,
+}
+
+var reverseMethodMap = map[methodTyp]string{
+ mCONNECT: http.MethodConnect,
+ mDELETE: http.MethodDelete,
+ mGET: http.MethodGet,
+ mHEAD: http.MethodHead,
+ mOPTIONS: http.MethodOptions,
+ mPATCH: http.MethodPatch,
+ mPOST: http.MethodPost,
+ mPUT: http.MethodPut,
+ mTRACE: http.MethodTrace,
+}
+
+// RegisterMethod adds support for custom HTTP method handlers, available
+// via Router#Method and Router#MethodFunc
+func RegisterMethod(method string) {
+ if method == "" {
+ return
+ }
+ method = strings.ToUpper(method)
+ if _, ok := methodMap[method]; ok {
+ return
+ }
+ n := len(methodMap)
+ if n > strconv.IntSize-2 {
+ panic(fmt.Sprintf("chi: max number of methods reached (%d)", strconv.IntSize))
+ }
+ mt := methodTyp(2 << n)
+ methodMap[method] = mt
+ mALL |= mt
+}
+
+type nodeTyp uint8
+
+const (
+ ntStatic nodeTyp = iota // /home
+ ntRegexp // /{id:[0-9]+}
+ ntParam // /{user}
+ ntCatchAll // /api/v1/*
+)
+
+type node struct {
+ // subroutes on the leaf node
+ subroutes Routes
+
+ // regexp matcher for regexp nodes
+ rex *regexp.Regexp
+
+ // HTTP handler endpoints on the leaf node
+ endpoints endpoints
+
+ // prefix is the common prefix we ignore
+ prefix string
+
+ // child nodes should be stored in-order for iteration,
+ // in groups of the node type.
+ children [ntCatchAll + 1]nodes
+
+ // first byte of the child prefix
+ tail byte
+
+ // node type: static, regexp, param, catchAll
+ typ nodeTyp
+
+ // first byte of the prefix
+ label byte
+}
+
+// endpoints is a mapping of http method constants to handlers
+// for a given route.
+type endpoints map[methodTyp]*endpoint
+
+type endpoint struct {
+ // endpoint handler
+ handler http.Handler
+
+ // pattern is the routing pattern for handler nodes
+ pattern string
+
+ // parameter keys recorded on handler nodes
+ paramKeys []string
+}
+
+func (s endpoints) Value(method methodTyp) *endpoint {
+ mh, ok := s[method]
+ if !ok {
+ mh = &endpoint{}
+ s[method] = mh
+ }
+ return mh
+}
+
+func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {
+ var parent *node
+ search := pattern
+
+ for {
+ // Handle key exhaustion
+ if len(search) == 0 {
+ // Insert or update the node's leaf handler
+ n.setEndpoint(method, handler, pattern)
+ return n
+ }
+
+ // We're going to be searching for a wild node next,
+ // in this case, we need to get the tail
+ var label = search[0]
+ var segTail byte
+ var segEndIdx int
+ var segTyp nodeTyp
+ var segRexpat string
+ if label == '{' || label == '*' {
+ segTyp, _, segRexpat, segTail, _, segEndIdx = patNextSegment(search)
+ }
+
+ var prefix string
+ if segTyp == ntRegexp {
+ prefix = segRexpat
+ }
+
+ // Look for the edge to attach to
+ parent = n
+ n = n.getEdge(segTyp, label, segTail, prefix)
+
+ // No edge, create one
+ if n == nil {
+ child := &node{label: label, tail: segTail, prefix: search}
+ hn := parent.addChild(child, search)
+ hn.setEndpoint(method, handler, pattern)
+
+ return hn
+ }
+
+ // Found an edge to match the pattern
+
+ if n.typ > ntStatic {
+ // We found a param node, trim the param from the search path and continue.
+ // This param/wild pattern segment would already be on the tree from a previous
+ // call to addChild when creating a new node.
+ search = search[segEndIdx:]
+ continue
+ }
+
+ // Static nodes fall below here.
+ // Determine longest prefix of the search key on match.
+ commonPrefix := longestPrefix(search, n.prefix)
+ if commonPrefix == len(n.prefix) {
+ // the common prefix is as long as the current node's prefix we're attempting to insert.
+ // keep the search going.
+ search = search[commonPrefix:]
+ continue
+ }
+
+ // Split the node
+ child := &node{
+ typ: ntStatic,
+ prefix: search[:commonPrefix],
+ }
+ parent.replaceChild(search[0], segTail, child)
+
+ // Restore the existing node
+ n.label = n.prefix[commonPrefix]
+ n.prefix = n.prefix[commonPrefix:]
+ child.addChild(n, n.prefix)
+
+ // If the new key is a subset, set the method/handler on this node and finish.
+ search = search[commonPrefix:]
+ if len(search) == 0 {
+ child.setEndpoint(method, handler, pattern)
+ return child
+ }
+
+ // Create a new edge for the node
+ subchild := &node{
+ typ: ntStatic,
+ label: search[0],
+ prefix: search,
+ }
+ hn := child.addChild(subchild, search)
+ hn.setEndpoint(method, handler, pattern)
+ return hn
+ }
+}
+
+// addChild appends the new `child` node to the tree using the `pattern` as the trie key.
+// For a URL router like chi's, we split the static, param, regexp and wildcard segments
+// into different nodes. In addition, addChild will recursively call itself until every
+// pattern segment is added to the url pattern tree as individual nodes, depending on type.
+func (n *node) addChild(child *node, prefix string) *node {
+ search := prefix
+
+ // handler leaf node added to the tree is the child.
+ // this may be overridden later down the flow
+ hn := child
+
+ // Parse next segment
+ segTyp, _, segRexpat, segTail, segStartIdx, segEndIdx := patNextSegment(search)
+
+ // Add child depending on next up segment
+ switch segTyp {
+
+ case ntStatic:
+ // Search prefix is all static (that is, has no params in path)
+ // noop
+
+ default:
+ // Search prefix contains a param, regexp or wildcard
+
+ if segTyp == ntRegexp {
+ rex, err := regexp.Compile(segRexpat)
+ if err != nil {
+ panic(fmt.Sprintf("chi: invalid regexp pattern '%s' in route param", segRexpat))
+ }
+ child.prefix = segRexpat
+ child.rex = rex
+ }
+
+ if segStartIdx == 0 {
+ // Route starts with a param
+ child.typ = segTyp
+
+ if segTyp == ntCatchAll {
+ segStartIdx = -1
+ } else {
+ segStartIdx = segEndIdx
+ }
+ if segStartIdx < 0 {
+ segStartIdx = len(search)
+ }
+ child.tail = segTail // for params, we set the tail
+
+ if segStartIdx != len(search) {
+ // add static edge for the remaining part, split the end.
+ // its not possible to have adjacent param nodes, so its certainly
+ // going to be a static node next.
+
+ search = search[segStartIdx:] // advance search position
+
+ nn := &node{
+ typ: ntStatic,
+ label: search[0],
+ prefix: search,
+ }
+ hn = child.addChild(nn, search)
+ }
+
+ } else if segStartIdx > 0 {
+ // Route has some param
+
+ // starts with a static segment
+ child.typ = ntStatic
+ child.prefix = search[:segStartIdx]
+ child.rex = nil
+
+ // add the param edge node
+ search = search[segStartIdx:]
+
+ nn := &node{
+ typ: segTyp,
+ label: search[0],
+ tail: segTail,
+ }
+ hn = child.addChild(nn, search)
+
+ }
+ }
+
+ n.children[child.typ] = append(n.children[child.typ], child)
+ n.children[child.typ].Sort()
+ return hn
+}
+
+func (n *node) replaceChild(label, tail byte, child *node) {
+ for i := 0; i < len(n.children[child.typ]); i++ {
+ if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {
+ n.children[child.typ][i] = child
+ n.children[child.typ][i].label = label
+ n.children[child.typ][i].tail = tail
+ return
+ }
+ }
+ panic("chi: replacing missing child")
+}
+
+func (n *node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *node {
+ nds := n.children[ntyp]
+ for i := 0; i < len(nds); i++ {
+ if nds[i].label == label && nds[i].tail == tail {
+ if ntyp == ntRegexp && nds[i].prefix != prefix {
+ continue
+ }
+ return nds[i]
+ }
+ }
+ return nil
+}
+
+func (n *node) setEndpoint(method methodTyp, handler http.Handler, pattern string) {
+ // Set the handler for the method type on the node
+ if n.endpoints == nil {
+ n.endpoints = make(endpoints)
+ }
+
+ paramKeys := patParamKeys(pattern)
+
+ if method&mSTUB == mSTUB {
+ n.endpoints.Value(mSTUB).handler = handler
+ }
+ if method&mALL == mALL {
+ h := n.endpoints.Value(mALL)
+ h.handler = handler
+ h.pattern = pattern
+ h.paramKeys = paramKeys
+ for _, m := range methodMap {
+ h := n.endpoints.Value(m)
+ h.handler = handler
+ h.pattern = pattern
+ h.paramKeys = paramKeys
+ }
+ } else {
+ h := n.endpoints.Value(method)
+ h.handler = handler
+ h.pattern = pattern
+ h.paramKeys = paramKeys
+ }
+}
+
+func (n *node) FindRoute(rctx *Context, method methodTyp, path string) (*node, endpoints, http.Handler) {
+ // Reset the context routing pattern and params
+ rctx.routePattern = ""
+ rctx.routeParams.Keys = rctx.routeParams.Keys[:0]
+ rctx.routeParams.Values = rctx.routeParams.Values[:0]
+
+ // Find the routing handlers for the path
+ rn := n.findRoute(rctx, method, path)
+ if rn == nil {
+ return nil, nil, nil
+ }
+
+ // Record the routing params in the request lifecycle
+ rctx.URLParams.Keys = append(rctx.URLParams.Keys, rctx.routeParams.Keys...)
+ rctx.URLParams.Values = append(rctx.URLParams.Values, rctx.routeParams.Values...)
+
+ // Record the routing pattern in the request lifecycle
+ if rn.endpoints[method].pattern != "" {
+ rctx.routePattern = rn.endpoints[method].pattern
+ rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.routePattern)
+ }
+
+ return rn, rn.endpoints, rn.endpoints[method].handler
+}
+
+// Recursive edge traversal by checking all nodeTyp groups along the way.
+// It's like searching through a multi-dimensional radix trie.
+func (n *node) findRoute(rctx *Context, method methodTyp, path string) *node {
+ nn := n
+ search := path
+
+ for t, nds := range nn.children {
+ ntyp := nodeTyp(t)
+ if len(nds) == 0 {
+ continue
+ }
+
+ var xn *node
+ xsearch := search
+
+ var label byte
+ if search != "" {
+ label = search[0]
+ }
+
+ switch ntyp {
+ case ntStatic:
+ xn = nds.findEdge(label)
+ if xn == nil || !strings.HasPrefix(xsearch, xn.prefix) {
+ continue
+ }
+ xsearch = xsearch[len(xn.prefix):]
+
+ case ntParam, ntRegexp:
+ // short-circuit and return no matching route for empty param values
+ if xsearch == "" {
+ continue
+ }
+
+ // serially loop through each node grouped by the tail delimiter
+ for idx := 0; idx < len(nds); idx++ {
+ xn = nds[idx]
+
+ // label for param nodes is the delimiter byte
+ p := strings.IndexByte(xsearch, xn.tail)
+
+ if p < 0 {
+ if xn.tail == '/' {
+ p = len(xsearch)
+ } else {
+ continue
+ }
+ } else if ntyp == ntRegexp && p == 0 {
+ continue
+ }
+
+ if ntyp == ntRegexp && xn.rex != nil {
+ if !xn.rex.MatchString(xsearch[:p]) {
+ continue
+ }
+ } else if strings.IndexByte(xsearch[:p], '/') != -1 {
+ // avoid a match across path segments
+ continue
+ }
+
+ prevlen := len(rctx.routeParams.Values)
+ rctx.routeParams.Values = append(rctx.routeParams.Values, xsearch[:p])
+ xsearch = xsearch[p:]
+
+ if len(xsearch) == 0 {
+ if xn.isLeaf() {
+ h := xn.endpoints[method]
+ if h != nil && h.handler != nil {
+ rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
+ return xn
+ }
+
+ for endpoints := range xn.endpoints {
+ if endpoints == mALL || endpoints == mSTUB {
+ continue
+ }
+ rctx.methodsAllowed = append(rctx.methodsAllowed, endpoints)
+ }
+
+ // flag that the routing context found a route, but not a corresponding
+ // supported method
+ rctx.methodNotAllowed = true
+ }
+ }
+
+ // recursively find the next node on this branch
+ fin := xn.findRoute(rctx, method, xsearch)
+ if fin != nil {
+ return fin
+ }
+
+ // not found on this branch, reset vars
+ rctx.routeParams.Values = rctx.routeParams.Values[:prevlen]
+ xsearch = search
+ }
+
+ rctx.routeParams.Values = append(rctx.routeParams.Values, "")
+
+ default:
+ // catch-all nodes
+ rctx.routeParams.Values = append(rctx.routeParams.Values, search)
+ xn = nds[0]
+ xsearch = ""
+ }
+
+ if xn == nil {
+ continue
+ }
+
+ // did we find it yet?
+ if len(xsearch) == 0 {
+ if xn.isLeaf() {
+ h := xn.endpoints[method]
+ if h != nil && h.handler != nil {
+ rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
+ return xn
+ }
+
+ for endpoints := range xn.endpoints {
+ if endpoints == mALL || endpoints == mSTUB {
+ continue
+ }
+ rctx.methodsAllowed = append(rctx.methodsAllowed, endpoints)
+ }
+
+ // flag that the routing context found a route, but not a corresponding
+ // supported method
+ rctx.methodNotAllowed = true
+ }
+ }
+
+ // recursively find the next node..
+ fin := xn.findRoute(rctx, method, xsearch)
+ if fin != nil {
+ return fin
+ }
+
+ // Did not find final handler, let's remove the param here if it was set
+ if xn.typ > ntStatic {
+ if len(rctx.routeParams.Values) > 0 {
+ rctx.routeParams.Values = rctx.routeParams.Values[:len(rctx.routeParams.Values)-1]
+ }
+ }
+
+ }
+
+ return nil
+}
+
+func (n *node) findEdge(ntyp nodeTyp, label byte) *node {
+ nds := n.children[ntyp]
+ num := len(nds)
+ idx := 0
+
+ switch ntyp {
+ case ntStatic, ntParam, ntRegexp:
+ i, j := 0, num-1
+ for i <= j {
+ idx = i + (j-i)/2
+ if label > nds[idx].label {
+ i = idx + 1
+ } else if label < nds[idx].label {
+ j = idx - 1
+ } else {
+ i = num // breaks cond
+ }
+ }
+ if nds[idx].label != label {
+ return nil
+ }
+ return nds[idx]
+
+ default: // catch all
+ return nds[idx]
+ }
+}
+
+func (n *node) isLeaf() bool {
+ return n.endpoints != nil
+}
+
+func (n *node) findPattern(pattern string) bool {
+ nn := n
+ for _, nds := range nn.children {
+ if len(nds) == 0 {
+ continue
+ }
+
+ n = nn.findEdge(nds[0].typ, pattern[0])
+ if n == nil {
+ continue
+ }
+
+ var idx int
+ var xpattern string
+
+ switch n.typ {
+ case ntStatic:
+ idx = longestPrefix(pattern, n.prefix)
+ if idx < len(n.prefix) {
+ continue
+ }
+
+ case ntParam, ntRegexp:
+ idx = strings.IndexByte(pattern, '}') + 1
+
+ case ntCatchAll:
+ idx = longestPrefix(pattern, "*")
+
+ default:
+ panic("chi: unknown node type")
+ }
+
+ xpattern = pattern[idx:]
+ if len(xpattern) == 0 {
+ return true
+ }
+
+ return n.findPattern(xpattern)
+ }
+ return false
+}
+
+func (n *node) routes() []Route {
+ rts := []Route{}
+
+ n.walk(func(eps endpoints, subroutes Routes) bool {
+ if eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil {
+ return false
+ }
+
+ // Group methodHandlers by unique patterns
+ pats := make(map[string]endpoints)
+
+ for mt, h := range eps {
+ if h.pattern == "" {
+ continue
+ }
+ p, ok := pats[h.pattern]
+ if !ok {
+ p = endpoints{}
+ pats[h.pattern] = p
+ }
+ p[mt] = h
+ }
+
+ for p, mh := range pats {
+ hs := make(map[string]http.Handler)
+ if mh[mALL] != nil && mh[mALL].handler != nil {
+ hs["*"] = mh[mALL].handler
+ }
+
+ for mt, h := range mh {
+ if h.handler == nil {
+ continue
+ }
+ m := methodTypString(mt)
+ if m == "" {
+ continue
+ }
+ hs[m] = h.handler
+ }
+
+ rt := Route{subroutes, hs, p}
+ rts = append(rts, rt)
+ }
+
+ return false
+ })
+
+ return rts
+}
+
+func (n *node) walk(fn func(eps endpoints, subroutes Routes) bool) bool {
+ // Visit the leaf values if any
+ if (n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) {
+ return true
+ }
+
+ // Recurse on the children
+ for _, ns := range n.children {
+ for _, cn := range ns {
+ if cn.walk(fn) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// patNextSegment returns the next segment details from a pattern:
+// node type, param key, regexp string, param tail byte, param starting index, param ending index
+func patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int) {
+ ps := strings.Index(pattern, "{")
+ ws := strings.Index(pattern, "*")
+
+ if ps < 0 && ws < 0 {
+ return ntStatic, "", "", 0, 0, len(pattern) // we return the entire thing
+ }
+
+ // Sanity check
+ if ps >= 0 && ws >= 0 && ws < ps {
+ panic("chi: wildcard '*' must be the last pattern in a route, otherwise use a '{param}'")
+ }
+
+ var tail byte = '/' // Default endpoint tail to / byte
+
+ if ps >= 0 {
+ // Param/Regexp pattern is next
+ nt := ntParam
+
+ // Read to closing } taking into account opens and closes in curl count (cc)
+ cc := 0
+ pe := ps
+ for i, c := range pattern[ps:] {
+ if c == '{' {
+ cc++
+ } else if c == '}' {
+ cc--
+ if cc == 0 {
+ pe = ps + i
+ break
+ }
+ }
+ }
+ if pe == ps {
+ panic("chi: route param closing delimiter '}' is missing")
+ }
+
+ key := pattern[ps+1 : pe]
+ pe++ // set end to next position
+
+ if pe < len(pattern) {
+ tail = pattern[pe]
+ }
+
+ var rexpat string
+ if idx := strings.Index(key, ":"); idx >= 0 {
+ nt = ntRegexp
+ rexpat = key[idx+1:]
+ key = key[:idx]
+ }
+
+ if len(rexpat) > 0 {
+ if rexpat[0] != '^' {
+ rexpat = "^" + rexpat
+ }
+ if rexpat[len(rexpat)-1] != '$' {
+ rexpat += "$"
+ }
+ }
+
+ return nt, key, rexpat, tail, ps, pe
+ }
+
+ // Wildcard pattern as finale
+ if ws < len(pattern)-1 {
+ panic("chi: wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead")
+ }
+ return ntCatchAll, "*", "", 0, ws, len(pattern)
+}
+
+func patParamKeys(pattern string) []string {
+ pat := pattern
+ paramKeys := []string{}
+ for {
+ ptyp, paramKey, _, _, _, e := patNextSegment(pat)
+ if ptyp == ntStatic {
+ return paramKeys
+ }
+ for i := 0; i < len(paramKeys); i++ {
+ if paramKeys[i] == paramKey {
+ panic(fmt.Sprintf("chi: routing pattern '%s' contains duplicate param key, '%s'", pattern, paramKey))
+ }
+ }
+ paramKeys = append(paramKeys, paramKey)
+ pat = pat[e:]
+ }
+}
+
+// longestPrefix finds the length of the shared prefix
+// of two strings
+func longestPrefix(k1, k2 string) int {
+ max := len(k1)
+ if l := len(k2); l < max {
+ max = l
+ }
+ var i int
+ for i = 0; i < max; i++ {
+ if k1[i] != k2[i] {
+ break
+ }
+ }
+ return i
+}
+
+func methodTypString(method methodTyp) string {
+ for s, t := range methodMap {
+ if method == t {
+ return s
+ }
+ }
+ return ""
+}
+
+type nodes []*node
+
+// Sort the list of nodes by label
+func (ns nodes) Sort() { sort.Sort(ns); ns.tailSort() }
+func (ns nodes) Len() int { return len(ns) }
+func (ns nodes) Swap(i, j int) { ns[i], ns[j] = ns[j], ns[i] }
+func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
+
+// tailSort pushes nodes with '/' as the tail to the end of the list for param nodes.
+// The list order determines the traversal order.
+func (ns nodes) tailSort() {
+ for i := len(ns) - 1; i >= 0; i-- {
+ if ns[i].typ > ntStatic && ns[i].tail == '/' {
+ ns.Swap(i, len(ns)-1)
+ return
+ }
+ }
+}
+
+func (ns nodes) findEdge(label byte) *node {
+ num := len(ns)
+ idx := 0
+ i, j := 0, num-1
+ for i <= j {
+ idx = i + (j-i)/2
+ if label > ns[idx].label {
+ i = idx + 1
+ } else if label < ns[idx].label {
+ j = idx - 1
+ } else {
+ i = num // breaks cond
+ }
+ }
+ if ns[idx].label != label {
+ return nil
+ }
+ return ns[idx]
+}
+
+// Route describes the details of a routing handler.
+// Handlers map key is an HTTP method
+type Route struct {
+ SubRoutes Routes
+ Handlers map[string]http.Handler
+ Pattern string
+}
+
+// WalkFunc is the type of the function called for each method and route visited by Walk.
+type WalkFunc func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error
+
+// Walk walks any router tree that implements Routes interface.
+func Walk(r Routes, walkFn WalkFunc) error {
+ return walk(r, walkFn, "")
+}
+
+func walk(r Routes, walkFn WalkFunc, parentRoute string, parentMw ...func(http.Handler) http.Handler) error {
+ for _, route := range r.Routes() {
+ mws := make([]func(http.Handler) http.Handler, len(parentMw))
+ copy(mws, parentMw)
+ mws = append(mws, r.Middlewares()...)
+
+ if route.SubRoutes != nil {
+ if err := walk(route.SubRoutes, walkFn, parentRoute+route.Pattern, mws...); err != nil {
+ return err
+ }
+ continue
+ }
+
+ for method, handler := range route.Handlers {
+ if method == "*" {
+ // Ignore a "catchAll" method, since we pass down all the specific methods for each route.
+ continue
+ }
+
+ fullRoute := parentRoute + route.Pattern
+ fullRoute = strings.Replace(fullRoute, "/*/", "/", -1)
+
+ if chain, ok := handler.(*ChainHandler); ok {
+ if err := walkFn(method, fullRoute, chain.Endpoint, append(mws, chain.Middlewares...)...); err != nil {
+ return err
+ }
+ } else {
+ if err := walkFn(method, fullRoute, handler, mws...); err != nil {
+ return err
+ }
+ }
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/go-openapi/swag/util.go b/vendor/github.com/go-openapi/swag/util.go
index f78ab684a0..d971fbe34b 100644
--- a/vendor/github.com/go-openapi/swag/util.go
+++ b/vendor/github.com/go-openapi/swag/util.go
@@ -341,12 +341,21 @@ type zeroable interface {
// IsZero returns true when the value passed into the function is a zero value.
// This allows for safer checking of interface values.
func IsZero(data interface{}) bool {
+ v := reflect.ValueOf(data)
+ // check for nil data
+ switch v.Kind() {
+ case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+ if v.IsNil() {
+ return true
+ }
+ }
+
// check for things that have an IsZero method instead
if vv, ok := data.(zeroable); ok {
return vv.IsZero()
}
+
// continue with slightly more complex reflection
- v := reflect.ValueOf(data)
switch v.Kind() {
case reflect.String:
return v.Len() == 0
@@ -358,14 +367,13 @@ func IsZero(data interface{}) bool {
return v.Uint() == 0
case reflect.Float32, reflect.Float64:
return v.Float() == 0
- case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
- return v.IsNil()
case reflect.Struct, reflect.Array:
return reflect.DeepEqual(data, reflect.Zero(v.Type()).Interface())
case reflect.Invalid:
return true
+ default:
+ return false
}
- return false
}
// AddInitialisms add additional initialisms
diff --git a/vendor/goa.design/goa/v3/codegen/cli/cli.go b/vendor/goa.design/goa/v3/codegen/cli/cli.go
index 75541ffa03..3c3fc0f9c3 100644
--- a/vendor/goa.design/goa/v3/codegen/cli/cli.go
+++ b/vendor/goa.design/goa/v3/codegen/cli/cli.go
@@ -446,7 +446,7 @@ func jsonExample(v any) string {
ex = string(b)
}
if strings.Contains(ex, "\n") {
- ex = "'" + strings.Replace(ex, "'", "\\'", -1) + "'"
+ ex = "'" + strings.ReplaceAll(ex, "'", "\\'") + "'"
}
return ex
}
@@ -556,8 +556,8 @@ func goifyTerms(terms ...string) string {
}
func printDescription(desc string) string {
- res := strings.Replace(desc, "`", "`+\"`\"+`", -1)
- res = strings.Replace(res, "\n", "\n\t", -1)
+ res := strings.ReplaceAll(desc, "`", "`+\"`\"+`")
+ res = strings.ReplaceAll(res, "\n", "\n\t")
return res
}
@@ -580,7 +580,7 @@ func fieldCode(init *PayloadInitData) string {
// because the args cannot be user types.
c, _, err := codegen.InitStructFields(init.Args, varn, "", init.ReturnTypePkg)
if err != nil {
- panic(err) //bug
+ panic(err) // bug
}
return c
}
diff --git a/vendor/goa.design/goa/v3/codegen/example/example_cli.go b/vendor/goa.design/goa/v3/codegen/example/example_cli.go
index 05c28de597..ffef0f6015 100644
--- a/vendor/goa.design/goa/v3/codegen/example/example_cli.go
+++ b/vendor/goa.design/goa/v3/codegen/example/example_cli.go
@@ -23,7 +23,7 @@ func CLIFiles(genpkg string, root *expr.RootExpr) []*codegen.File {
// exampleCLIMain returns an example client tool main implementation for the
// given server expression.
-func exampleCLIMain(genpkg string, root *expr.RootExpr, svr *expr.ServerExpr) *codegen.File {
+func exampleCLIMain(_ string, root *expr.RootExpr, svr *expr.ServerExpr) *codegen.File {
svrdata := Servers.Get(svr)
path := filepath.Join("cmd", svrdata.Dir+"-cli", "main.go")
diff --git a/vendor/goa.design/goa/v3/codegen/file.go b/vendor/goa.design/goa/v3/codegen/file.go
index b58dd48d89..983aec10cd 100644
--- a/vendor/goa.design/goa/v3/codegen/file.go
+++ b/vendor/goa.design/goa/v3/codegen/file.go
@@ -82,14 +82,14 @@ func (f *File) Render(dir string) (string, error) {
}
}
- if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ if err := os.MkdirAll(filepath.Dir(path), 0750); err != nil {
return "", err
}
file, err := os.OpenFile(
path,
os.O_CREATE|os.O_APPEND|os.O_WRONLY,
- 0644,
+ 0600,
)
if err != nil {
return "", err
diff --git a/vendor/goa.design/goa/v3/codegen/funcs.go b/vendor/goa.design/goa/v3/codegen/funcs.go
index 49ff5d49cc..48501c4a94 100644
--- a/vendor/goa.design/goa/v3/codegen/funcs.go
+++ b/vendor/goa.design/goa/v3/codegen/funcs.go
@@ -169,7 +169,7 @@ func CamelCase(name string, firstUpper bool, acronym bool) string {
if w == 0 && !firstUpper {
runes[w] = unicode.ToLower(runes[w])
}
- //advance to next word
+ // advance to next word
w = i
}
@@ -183,7 +183,7 @@ func CamelCase(name string, firstUpper bool, acronym bool) string {
func SnakeCase(name string) string {
// Special handling for single "words" starting with multiple upper case letters
for u, l := range toLower {
- name = strings.Replace(name, u, l, -1)
+ name = strings.ReplaceAll(name, u, l)
}
// Remove leading and trailing blank spaces and replace any blank spaces in
@@ -191,7 +191,7 @@ func SnakeCase(name string) string {
name = strings.Join(strings.Fields(name), "_")
// Special handling for dashes to convert them into underscores
- name = strings.Replace(name, "-", "_", -1)
+ name = strings.ReplaceAll(name, "-", "_")
var b bytes.Buffer
ln := len(name)
@@ -200,7 +200,7 @@ func SnakeCase(name string) string {
}
n := rune(name[0])
b.WriteRune(unicode.ToLower(n))
- lastLower, isLower, lastUnder, isUnder := false, true, false, false
+ var lastLower, isLower, lastUnder, isUnder bool
for i := 1; i < ln; i++ {
r := rune(name[i])
isLower = unicode.IsLower(r) && unicode.IsLetter(r) || unicode.IsDigit(r)
@@ -229,7 +229,7 @@ func KebabCase(name string) string {
if name[ln-1] == '_' {
name = name[:ln-1]
}
- return strings.Replace(name, "_", "-", -1)
+ return strings.ReplaceAll(name, "_", "-")
}
// WrapText produces lines with text capped at maxChars
diff --git a/vendor/goa.design/goa/v3/codegen/generator/generate.go b/vendor/goa.design/goa/v3/codegen/generator/generate.go
index d61710b00f..5252009276 100644
--- a/vendor/goa.design/goa/v3/codegen/generator/generate.go
+++ b/vendor/goa.design/goa/v3/codegen/generator/generate.go
@@ -30,7 +30,7 @@ func Generate(dir, cmd string) (outputs []string, err1 error) {
return nil, err
}
path := filepath.Join(base, codegen.Gendir)
- if err := os.MkdirAll(path, 0777); err != nil {
+ if err := os.MkdirAll(path, 0750); err != nil {
return nil, err
}
diff --git a/vendor/goa.design/goa/v3/codegen/generator/service.go b/vendor/goa.design/goa/v3/codegen/generator/service.go
index 331a9a1d28..7f7169c42e 100644
--- a/vendor/goa.design/goa/v3/codegen/generator/service.go
+++ b/vendor/goa.design/goa/v3/codegen/generator/service.go
@@ -14,30 +14,31 @@ func Service(genpkg string, roots []eval.Root) ([]*codegen.File, error) {
var files []*codegen.File
var userTypePkgs = make(map[string][]string)
for _, root := range roots {
- switch r := root.(type) {
- case *expr.RootExpr:
- for _, s := range r.Services {
- // Make sure service is first so name scope is
- // properly initialized.
- files = append(files, service.Files(genpkg, s, userTypePkgs)...)
- files = append(files, service.EndpointFile(genpkg, s))
- files = append(files, service.ClientFile(genpkg, s))
- if f := service.ViewsFile(genpkg, s); f != nil {
- files = append(files, f)
- }
- for _, f := range files {
- if len(f.SectionTemplates) > 0 {
- service.AddServiceDataMetaTypeImports(f.SectionTemplates[0], s)
- }
- }
- f, err := service.ConvertFile(r, s)
- if err != nil {
- return nil, err
- }
- if f != nil {
- files = append(files, f)
+ r, ok := root.(*expr.RootExpr)
+ if !ok {
+ continue
+ }
+ for _, s := range r.Services {
+ // Make sure service is first so name scope is
+ // properly initialized.
+ files = append(files, service.Files(genpkg, s, userTypePkgs)...)
+ files = append(files, service.EndpointFile(genpkg, s))
+ files = append(files, service.ClientFile(genpkg, s))
+ if f := service.ViewsFile(genpkg, s); f != nil {
+ files = append(files, f)
+ }
+ for _, f := range files {
+ if len(f.SectionTemplates) > 0 {
+ service.AddServiceDataMetaTypeImports(f.SectionTemplates[0], s)
}
}
+ f, err := service.ConvertFile(r, s)
+ if err != nil {
+ return nil, err
+ }
+ if f != nil {
+ files = append(files, f)
+ }
}
}
return files, nil
diff --git a/vendor/goa.design/goa/v3/codegen/import.go b/vendor/goa.design/goa/v3/codegen/import.go
index 3fe22cda18..7cd44fe552 100644
--- a/vendor/goa.design/goa/v3/codegen/import.go
+++ b/vendor/goa.design/goa/v3/codegen/import.go
@@ -178,8 +178,8 @@ func safelyGetMetaTypeImports(att *expr.AttributeExpr, seen map[string]struct{})
}
for imp := range uniqueImports {
// Copy loop variable into body so next iteration doesn't overwrite its address https://stackoverflow.com/questions/27610039/golang-appending-leaves-only-last-element
- copy := imp
- imports = append(imports, ©)
+ cp := imp
+ imports = append(imports, &cp)
}
return imports
}
diff --git a/vendor/goa.design/goa/v3/codegen/scope.go b/vendor/goa.design/goa/v3/codegen/scope.go
index ac6cb09764..d3c34b679a 100644
--- a/vendor/goa.design/goa/v3/codegen/scope.go
+++ b/vendor/goa.design/goa/v3/codegen/scope.go
@@ -175,7 +175,7 @@ func (s *NameScope) goTypeDef(att *expr.AttributeExpr, ptr, useDefault bool, pkg
// GoVar returns the Go code that returns the address of a variable of the Go type
// which matches the given attribute type.
-func (s *NameScope) GoVar(varName string, dt expr.DataType) string {
+func (*NameScope) GoVar(varName string, dt expr.DataType) string {
// For a raw struct, no need to indirecting
if isRawStruct(dt) {
return varName
diff --git a/vendor/goa.design/goa/v3/codegen/service/client.go b/vendor/goa.design/goa/v3/codegen/service/client.go
index 56313d7b9e..d1e308cd1f 100644
--- a/vendor/goa.design/goa/v3/codegen/service/client.go
+++ b/vendor/goa.design/goa/v3/codegen/service/client.go
@@ -13,7 +13,7 @@ const (
)
// ClientFile returns the client file for the given service.
-func ClientFile(genpkg string, service *expr.ServiceExpr) *codegen.File {
+func ClientFile(_ string, service *expr.ServiceExpr) *codegen.File {
svc := Services.Get(service.Name)
data := endpointData(service)
path := filepath.Join(codegen.Gendir, svc.PathName, "client.go")
diff --git a/vendor/goa.design/goa/v3/codegen/service/convert.go b/vendor/goa.design/goa/v3/codegen/service/convert.go
index 1ff45861b4..0070e34d35 100644
--- a/vendor/goa.design/goa/v3/codegen/service/convert.go
+++ b/vendor/goa.design/goa/v3/codegen/service/convert.go
@@ -342,7 +342,7 @@ type dtRec struct {
seen map[string]expr.DataType
}
-func (r dtRec) append(p string) dtRec {
+func appendPath(r dtRec, p string) dtRec {
r.path += p
return r
}
@@ -414,7 +414,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
eref = expr.AsArray(ref).ElemType.Type
}
var elem expr.DataType
- if err := buildDesignType(&elem, e, eref, rec.append("[0]")); err != nil {
+ if err := buildDesignType(&elem, e, eref, appendPath(rec, "[0]")); err != nil {
return fmt.Errorf("%s", err)
}
*dt = &expr.Array{ElemType: &expr.AttributeExpr{Type: elem}}
@@ -427,11 +427,11 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
vref = m.ElemType.Type
}
var kt expr.DataType
- if err := buildDesignType(&kt, t.Key(), kref, rec.append(".key")); err != nil {
+ if err := buildDesignType(&kt, t.Key(), kref, appendPath(rec, ".key")); err != nil {
return fmt.Errorf("%s", err)
}
var vt expr.DataType
- if err := buildDesignType(&vt, t.Elem(), vref, rec.append(".value")); err != nil {
+ if err := buildDesignType(&vt, t.Elem(), vref, appendPath(rec, ".value")); err != nil {
return fmt.Errorf("%s", err)
}
*dt = &expr.Map{KeyType: &expr.AttributeExpr{Type: kt}, ElemType: &expr.AttributeExpr{Type: vt}}
@@ -475,7 +475,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
rec.seen[t.Name()] = ut
var required []string
for i, f := range fields {
- recf := rec.append("." + f.Name)
+ recf := appendPath(rec, "."+f.Name)
atn, fn := attributeName(oref, f.Name)
var aref expr.DataType
if oref != nil {
@@ -500,7 +500,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
if isPrimitive(f.Type) {
required = append(required, atn)
}
- if err := buildDesignType(&fdt, f.Type, aref, rec.append("."+f.Name)); err != nil {
+ if err := buildDesignType(&fdt, f.Type, aref, appendPath(rec, "."+f.Name)); err != nil {
return fmt.Errorf("%q.%s: %s", t.Name(), f.Name, err)
}
}
@@ -625,7 +625,7 @@ type compRec struct {
seen map[string]struct{}
}
-func (r compRec) append(p string) compRec {
+func appendCompPath(r compRec, p string) compRec {
r.path += p
return r
}
@@ -662,7 +662,7 @@ func compatible(from expr.DataType, to reflect.Type, recs ...compRec) error {
return compatible(
expr.AsArray(from).ElemType.Type,
to.Elem(),
- rec.append("[0]"),
+ appendCompPath(rec, "[0]"),
)
}
@@ -673,14 +673,14 @@ func compatible(from expr.DataType, to reflect.Type, recs ...compRec) error {
if err := compatible(
expr.AsMap(from).ElemType.Type,
to.Elem(),
- rec.append(".value"),
+ appendCompPath(rec, ".value"),
); err != nil {
return err
}
return compatible(
expr.AsMap(from).KeyType.Type,
to.Key(),
- rec.append(".key"),
+ appendCompPath(rec, ".key"),
)
}
@@ -722,7 +722,7 @@ func compatible(from expr.DataType, to reflect.Type, recs ...compRec) error {
err := compatible(
nat.Attribute.Type,
field.Type,
- rec.append("."+fname),
+ appendCompPath(rec, "."+fname),
)
if err != nil {
return err
diff --git a/vendor/goa.design/goa/v3/codegen/service/example_svc.go b/vendor/goa.design/goa/v3/codegen/service/example_svc.go
index e556ddd3af..98648e0962 100644
--- a/vendor/goa.design/goa/v3/codegen/service/example_svc.go
+++ b/vendor/goa.design/goa/v3/codegen/service/example_svc.go
@@ -58,7 +58,7 @@ func ExampleServiceFiles(genpkg string, root *expr.RootExpr) []*codegen.File {
}
// exampleServiceFile returns a basic implementation of the given service.
-func exampleServiceFile(genpkg string, root *expr.RootExpr, svc *expr.ServiceExpr, apipkg string) *codegen.File {
+func exampleServiceFile(genpkg string, _ *expr.RootExpr, svc *expr.ServiceExpr, apipkg string) *codegen.File {
data := Services.Get(svc.Name)
svcName := data.PathName
fpath := svcName + ".go"
diff --git a/vendor/goa.design/goa/v3/codegen/service/views.go b/vendor/goa.design/goa/v3/codegen/service/views.go
index f7d20de327..de03ddc5ac 100644
--- a/vendor/goa.design/goa/v3/codegen/service/views.go
+++ b/vendor/goa.design/goa/v3/codegen/service/views.go
@@ -16,7 +16,7 @@ type viewedType struct {
// ViewsFile returns the views file for the given service which contains
// logic to render result types using the defined views.
-func ViewsFile(genpkg string, service *expr.ServiceExpr) *codegen.File {
+func ViewsFile(_ string, service *expr.ServiceExpr) *codegen.File {
svc := Services.Get(service.Name)
if len(svc.projectedTypes) == 0 {
return nil
diff --git a/vendor/goa.design/goa/v3/codegen/testing.go b/vendor/goa.design/goa/v3/codegen/testing.go
index 6d5cea5157..058447b36f 100644
--- a/vendor/goa.design/goa/v3/codegen/testing.go
+++ b/vendor/goa.design/goa/v3/codegen/testing.go
@@ -20,8 +20,12 @@ func RunDSL(t *testing.T, dsl func()) *expr.RootExpr {
eval.Reset()
expr.Root = new(expr.RootExpr)
expr.Root.GeneratedTypes = &expr.GeneratedRoot{}
- eval.Register(expr.Root)
- eval.Register(expr.Root.GeneratedTypes)
+ if err := eval.Register(expr.Root); err != nil {
+ t.Fatal(err)
+ }
+ if err := eval.Register(expr.Root.GeneratedTypes); err != nil {
+ t.Fatal(err)
+ }
expr.Root.API = expr.NewAPIExpr("test api", func() {})
expr.Root.API.Servers = []*expr.ServerExpr{expr.Root.API.DefaultServer()}
if !eval.Execute(dsl, nil) {
@@ -105,7 +109,7 @@ func Diff(t *testing.T, s1, s2 string) string {
defer os.Remove(right)
cmd := exec.Command("diff", left, right)
diffb, _ := cmd.CombinedOutput()
- return strings.Replace(string(diffb), "\t", " ␉ ", -1)
+ return strings.ReplaceAll(string(diffb), "\t", " ␉ ")
}
// CreateTempFile creates a temporary file and writes the given content.
diff --git a/vendor/goa.design/goa/v3/codegen/transformer.go b/vendor/goa.design/goa/v3/codegen/transformer.go
index db319742d3..f4e0ba8787 100644
--- a/vendor/goa.design/goa/v3/codegen/transformer.go
+++ b/vendor/goa.design/goa/v3/codegen/transformer.go
@@ -251,7 +251,7 @@ func (a *AttributeScope) Ref(att *expr.AttributeExpr, pkg string) string {
}
// Field returns a valid Go struct field name.
-func (a *AttributeScope) Field(att *expr.AttributeExpr, name string, firstUpper bool) string {
+func (*AttributeScope) Field(att *expr.AttributeExpr, name string, firstUpper bool) string {
return GoifyAtt(att, name, firstUpper)
}
diff --git a/vendor/goa.design/goa/v3/codegen/types.go b/vendor/goa.design/goa/v3/codegen/types.go
index 9734c2f7f8..e02921865f 100644
--- a/vendor/goa.design/goa/v3/codegen/types.go
+++ b/vendor/goa.design/goa/v3/codegen/types.go
@@ -42,7 +42,7 @@ func GoNativeTypeName(t expr.DataType) string {
}
// AttributeTags computes the struct field tags from its metadata if any.
-func AttributeTags(parent, att *expr.AttributeExpr) string {
+func AttributeTags(_, att *expr.AttributeExpr) string {
var elems []string
keys := make([]string, len(att.Meta))
i := 0
diff --git a/vendor/goa.design/goa/v3/codegen/validation.go b/vendor/goa.design/goa/v3/codegen/validation.go
index 864d69eebe..2ff933cd00 100644
--- a/vendor/goa.design/goa/v3/codegen/validation.go
+++ b/vendor/goa.design/goa/v3/codegen/validation.go
@@ -365,7 +365,7 @@ func hasValidations(attCtx *AttributeContext, ut expr.UserType) bool {
// generated to avoid infinite recursions.
res := false
done := errors.New("done")
- Walk(ut.Attribute(), func(a *expr.AttributeExpr) error {
+ Walk(ut.Attribute(), func(a *expr.AttributeExpr) error { // nolint: errcheck
if a.Validation == nil {
return nil
}
diff --git a/vendor/goa.design/goa/v3/eval/eval.go b/vendor/goa.design/goa/v3/eval/eval.go
index 83277e5047..d8876760ae 100644
--- a/vendor/goa.design/goa/v3/eval/eval.go
+++ b/vendor/goa.design/goa/v3/eval/eval.go
@@ -169,7 +169,7 @@ func (verr *ValidationErrors) AddError(def Expression, err error) {
// runSet executes the DSL for all expressions in the given set. The expression
// DSLs may append to the set as they execute.
-func runSet(set ExpressionSet) error {
+func runSet(set ExpressionSet) {
executed := 0
recursed := 0
for executed < len(set) {
@@ -184,15 +184,15 @@ func runSet(set ExpressionSet) error {
}
}
if recursed > 100 {
- return fmt.Errorf("too many generated expressions, infinite loop?")
+ Context.Record(&Error{GoError: fmt.Errorf("too many generated expressions, infinite loop?")})
+ return
}
}
- return nil
}
// prepareSet runs the pre validation steps on all the set expressions that
// define one.
-func prepareSet(set ExpressionSet) error {
+func prepareSet(set ExpressionSet) {
for _, def := range set {
if def == nil {
continue
@@ -201,11 +201,10 @@ func prepareSet(set ExpressionSet) error {
p.Prepare()
}
}
- return nil
}
// validateSet runs the validation on all the set expressions that define one.
-func validateSet(set ExpressionSet) error {
+func validateSet(set ExpressionSet) {
errors := &ValidationErrors{}
for _, def := range set {
if def == nil {
@@ -220,11 +219,10 @@ func validateSet(set ExpressionSet) error {
if len(errors.Errors) > 0 {
Context.Record(&Error{GoError: errors})
}
- return Context.Errors
}
// finalizeSet runs the finalizer on all the set expressions that define one.
-func finalizeSet(set ExpressionSet) error {
+func finalizeSet(set ExpressionSet) {
for _, def := range set {
if def == nil {
continue
@@ -233,7 +231,6 @@ func finalizeSet(set ExpressionSet) error {
f.Finalize()
}
}
- return nil
}
// caller returns the name of calling function.
diff --git a/vendor/goa.design/goa/v3/eval/expression.go b/vendor/goa.design/goa/v3/eval/expression.go
index e44841ade3..d50ecbe79e 100644
--- a/vendor/goa.design/goa/v3/eval/expression.go
+++ b/vendor/goa.design/goa/v3/eval/expression.go
@@ -84,7 +84,7 @@ type (
// SetWalker is the function signature used to iterate over expression sets
// with WalkSets.
- SetWalker func(s ExpressionSet) error
+ SetWalker func(s ExpressionSet)
)
// Top is the expression returned by Current when the execution stack is empty.
diff --git a/vendor/goa.design/goa/v3/expr/attribute.go b/vendor/goa.design/goa/v3/expr/attribute.go
index d1296907e9..8ebcc03951 100644
--- a/vendor/goa.design/goa/v3/expr/attribute.go
+++ b/vendor/goa.design/goa/v3/expr/attribute.go
@@ -149,7 +149,7 @@ const (
)
// EvalName returns the name used by the DSL evaluation.
-func (a *AttributeExpr) EvalName() string {
+func (*AttributeExpr) EvalName() string {
return "attribute"
}
@@ -925,7 +925,7 @@ func (v *ValidationExpr) Debug(title, prefix, indent string) {
}
// IsSupportedValidationFormat checks if the validation format is supported by goa.
-func (a *AttributeExpr) IsSupportedValidationFormat(vf ValidationFormat) bool {
+func (*AttributeExpr) IsSupportedValidationFormat(vf ValidationFormat) bool {
switch vf {
case FormatDate:
return true
diff --git a/vendor/goa.design/goa/v3/expr/example.go b/vendor/goa.design/goa/v3/expr/example.go
index 1b0e44cd6a..b3f3dab4f1 100644
--- a/vendor/goa.design/goa/v3/expr/example.go
+++ b/vendor/goa.design/goa/v3/expr/example.go
@@ -26,6 +26,10 @@ func (a *AttributeExpr) Example(r *ExampleGenerator) any {
return ex[len(ex)-1].Value
}
+ if r.Randomizer == nil {
+ return nil
+ }
+
value, ok := a.Meta.Last("openapi:example")
if !ok {
value, ok = a.Meta.Last("swagger:example")
@@ -240,7 +244,7 @@ func byMinMax(a *AttributeExpr, r *ExampleGenerator) any {
return nil
}
var (
- min = math.Inf(-1)
+ min float64
max = math.Inf(1)
sign = 1
)
diff --git a/vendor/goa.design/goa/v3/expr/generated.go b/vendor/goa.design/goa/v3/expr/generated.go
index 15f5648a79..e0bad4fda0 100644
--- a/vendor/goa.design/goa/v3/expr/generated.go
+++ b/vendor/goa.design/goa/v3/expr/generated.go
@@ -9,7 +9,7 @@ type (
)
// EvalName is the name of the expression used by eval.
-func (r *GeneratedRoot) EvalName() string {
+func (*GeneratedRoot) EvalName() string {
return "generated result types"
}
@@ -28,12 +28,12 @@ func (r *GeneratedRoot) WalkSets(w eval.SetWalker) {
}
// DependsOn ensures that Root executes first.
-func (r *GeneratedRoot) DependsOn() []eval.Root {
+func (*GeneratedRoot) DependsOn() []eval.Root {
return []eval.Root{Root}
}
// Packages returns the Go import path to this and the dsl packages.
-func (r *GeneratedRoot) Packages() []string {
+func (*GeneratedRoot) Packages() []string {
return []string{
"goa.design/goa/v3/expr",
"goa.design/goa/v3/dsl",
diff --git a/vendor/goa.design/goa/v3/expr/grpc.go b/vendor/goa.design/goa/v3/expr/grpc.go
index ad7bc299eb..db5c3c245b 100644
--- a/vendor/goa.design/goa/v3/expr/grpc.go
+++ b/vendor/goa.design/goa/v3/expr/grpc.go
@@ -34,6 +34,6 @@ func (g *GRPCExpr) ServiceFor(s *ServiceExpr) *GRPCServiceExpr {
}
// EvalName returns the name printed in case of evaluation error.
-func (g *GRPCExpr) EvalName() string {
+func (*GRPCExpr) EvalName() string {
return "API GRPC"
}
diff --git a/vendor/goa.design/goa/v3/expr/grpc_endpoint.go b/vendor/goa.design/goa/v3/expr/grpc_endpoint.go
index d752bf02b7..5e75fbb8d1 100644
--- a/vendor/goa.design/goa/v3/expr/grpc_endpoint.go
+++ b/vendor/goa.design/goa/v3/expr/grpc_endpoint.go
@@ -215,10 +215,8 @@ func (e *GRPCEndpointExpr) Validate() error {
verr.Merge(validateRPCTags(msgFields, e))
}
}
- } else {
- if hasMessage && hasMetadata {
- verr.Add(e, "Both request message and metadata are defined, but payload is not an object. Define either metadata or message or make payload an object type.")
- }
+ } else if hasMessage && hasMetadata {
+ verr.Add(e, "Both request message and metadata are defined, but payload is not an object. Define either metadata or message or make payload an object type.")
}
// Validate response
@@ -489,7 +487,8 @@ func validateMetadata(metAtt *MappedAttributeExpr, serviceAtt *AttributeExpr, e
// getSecurityAttributes returns the attributes that describes a security
// scheme from a method expression.
func getSecurityAttributes(m *MethodExpr) []string {
- secAttrs := []string{}
+ var secAttrs []string
+
for _, req := range m.Requirements {
for _, sch := range req.Schemes {
switch sch.Kind {
diff --git a/vendor/goa.design/goa/v3/expr/http.go b/vendor/goa.design/goa/v3/expr/http.go
index 23a418997f..557adb64e4 100644
--- a/vendor/goa.design/goa/v3/expr/http.go
+++ b/vendor/goa.design/goa/v3/expr/http.go
@@ -71,7 +71,7 @@ func (h *HTTPExpr) ServiceFor(s *ServiceExpr) *HTTPServiceExpr {
}
// EvalName returns the name printed in case of evaluation error.
-func (h *HTTPExpr) EvalName() string {
+func (*HTTPExpr) EvalName() string {
return "API HTTP"
}
diff --git a/vendor/goa.design/goa/v3/expr/http_endpoint.go b/vendor/goa.design/goa/v3/expr/http_endpoint.go
index 16ace3eb61..9f84995116 100644
--- a/vendor/goa.design/goa/v3/expr/http_endpoint.go
+++ b/vendor/goa.design/goa/v3/expr/http_endpoint.go
@@ -216,7 +216,7 @@ func (e *HTTPEndpointExpr) Prepare() {
params.Merge(cpp)
// Inherit attributes for path params from parent service
- WalkMappedAttr(cpp, func(name, _ string, _ *AttributeExpr) error {
+ WalkMappedAttr(cpp, func(name, _ string, _ *AttributeExpr) error { // nolint: errcheck
if att := c.MethodExpr.Payload.Find(name); att != nil {
if e.MethodExpr.Payload.Type == Empty {
e.MethodExpr.Payload.Type = &Object{}
@@ -745,7 +745,7 @@ func (e *HTTPEndpointExpr) validateParams() *eval.ValidationErrors {
verr.Add(e, "path parameter %s cannot be an object, path parameter types must be primitive, array or map (query string only)", name)
}
verr := new(eval.ValidationErrors)
- WalkMappedAttr(pparams, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(pparams, func(name, _ string, a *AttributeExpr) error { // nolint: errcheck
switch {
case IsObject(a.Type), IsMap(a.Type), IsUnion(a.Type):
invalidTypeErr(verr, e, name)
@@ -760,7 +760,7 @@ func (e *HTTPEndpointExpr) validateParams() *eval.ValidationErrors {
}
return nil
})
- WalkMappedAttr(qparams, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(qparams, func(name, _ string, a *AttributeExpr) error { // nolint: errcheck
switch {
case IsObject(a.Type), IsUnion(a.Type):
invalidTypeErr(verr, e, name)
@@ -778,13 +778,13 @@ func (e *HTTPEndpointExpr) validateParams() *eval.ValidationErrors {
if e.MethodExpr.Payload != nil {
switch e.MethodExpr.Payload.Type.(type) {
case *Object, UserType:
- WalkMappedAttr(pparams, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(pparams, func(name, _ string, _ *AttributeExpr) error { // nolint: errcheck
if e.MethodExpr.Payload.Find(name) == nil {
verr.Add(e, "Path parameter %q not found in payload.", name)
}
return nil
})
- WalkMappedAttr(qparams, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(qparams, func(name, _ string, _ *AttributeExpr) error { // nolint: errcheck
if e.MethodExpr.Payload.Find(name) == nil {
verr.Add(e, "Query string parameter %q not found in payload.", name)
}
@@ -815,7 +815,7 @@ func (e *HTTPEndpointExpr) validateHeadersAndCookies() *eval.ValidationErrors {
cookies := DupMappedAtt(e.Cookies)
initAttr(headers, e.MethodExpr.Payload)
initAttr(cookies, e.MethodExpr.Payload)
- WalkMappedAttr(headers, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(headers, func(name, _ string, a *AttributeExpr) error { // nolint: errcheck
switch {
case IsObject(a.Type), IsUnion(a.Type):
verr.Add(e, "header %q must be primitive or array", name)
@@ -830,7 +830,7 @@ func (e *HTTPEndpointExpr) validateHeadersAndCookies() *eval.ValidationErrors {
}
return nil
})
- WalkMappedAttr(cookies, func(name, _ string, a *AttributeExpr) error {
+ WalkMappedAttr(cookies, func(name, _ string, a *AttributeExpr) error { // nolint: errcheck
switch {
case IsObject(a.Type), IsUnion(a.Type), IsArray(a.Type):
verr.Add(e, "cookie %q must be primitive", name)
@@ -843,7 +843,7 @@ func (e *HTTPEndpointExpr) validateHeadersAndCookies() *eval.ValidationErrors {
switch e.MethodExpr.Payload.Type.(type) {
case *Object, UserType:
hasBasicAuth := TaggedAttribute(e.MethodExpr.Payload, "security:username") != ""
- WalkMappedAttr(headers, func(name, elem string, a *AttributeExpr) error {
+ WalkMappedAttr(headers, func(name, elem string, _ *AttributeExpr) error { // nolint: errcheck
if e.MethodExpr.Payload.Find(name) == nil {
verr.Add(e, "header %q not found in payload.", name)
}
@@ -855,7 +855,7 @@ func (e *HTTPEndpointExpr) validateHeadersAndCookies() *eval.ValidationErrors {
}
return nil
})
- WalkMappedAttr(cookies, func(name, elem string, a *AttributeExpr) error {
+ WalkMappedAttr(cookies, func(name, _ string, _ *AttributeExpr) error { // nolint: errcheck
if e.MethodExpr.Payload.Find(name) == nil {
verr.Add(e, "cookie %q not found in payload.", name)
}
diff --git a/vendor/goa.design/goa/v3/expr/method.go b/vendor/goa.design/goa/v3/expr/method.go
index 95d5715665..902a84c713 100644
--- a/vendor/goa.design/goa/v3/expr/method.go
+++ b/vendor/goa.design/goa/v3/expr/method.go
@@ -201,7 +201,7 @@ func (m *MethodExpr) Validate() error {
// presence of struct:error:name meta in the object type.
if i != j && e.Type == e2.Type && IsObject(e.Type) {
var found bool
- walkAttribute(e.AttributeExpr, func(name string, att *AttributeExpr) error {
+ walkAttribute(e.AttributeExpr, func(_ string, att *AttributeExpr) error { // nolint: errcheck
if _, ok := att.Meta["struct:error:name"]; ok {
found = true
return fmt.Errorf("struct:error:name found: stop iteration")
diff --git a/vendor/goa.design/goa/v3/expr/random.go b/vendor/goa.design/goa/v3/expr/random.go
index 0a390de04f..d718895348 100644
--- a/vendor/goa.design/goa/v3/expr/random.go
+++ b/vendor/goa.design/goa/v3/expr/random.go
@@ -14,6 +14,8 @@ import (
//
// The random values should be consistent in that given the same seed the same
// random values get generated.
+//
+// Setting the randomizer to nil disables example generation.
type Randomizer interface {
// ArrayLength decides how long an example array will be
ArrayLength() int
diff --git a/vendor/goa.design/goa/v3/expr/result_type.go b/vendor/goa.design/goa/v3/expr/result_type.go
index b0d6c89a5e..882900f09a 100644
--- a/vendor/goa.design/goa/v3/expr/result_type.go
+++ b/vendor/goa.design/goa/v3/expr/result_type.go
@@ -126,7 +126,7 @@ func CanonicalIdentifier(identifier string) string {
}
// Kind implements DataKind.
-func (m *ResultTypeExpr) Kind() Kind { return ResultTypeKind }
+func (*ResultTypeExpr) Kind() Kind { return ResultTypeKind }
// Dup creates a deep copy of the result type given a deep copy of its attribute.
func (m *ResultTypeExpr) Dup(att *AttributeExpr) UserType {
@@ -178,7 +178,7 @@ func (m *ResultTypeExpr) Finalize() {
}
m.UserTypeExpr.Finalize()
seen := make(map[string]struct{})
- walkAttribute(m.AttributeExpr, func(_ string, att *AttributeExpr) error {
+ walkAttribute(m.AttributeExpr, func(_ string, att *AttributeExpr) error { // nolint: errcheck
if rt, ok := att.Type.(*ResultTypeExpr); ok {
if _, ok := seen[rt.Identifier]; !ok {
seen[rt.Identifier] = struct{}{}
diff --git a/vendor/goa.design/goa/v3/expr/root.go b/vendor/goa.design/goa/v3/expr/root.go
index 591b65b488..6cc0a74a7e 100644
--- a/vendor/goa.design/goa/v3/expr/root.go
+++ b/vendor/goa.design/goa/v3/expr/root.go
@@ -130,10 +130,10 @@ func (r *RootExpr) WalkSets(walk eval.SetWalker) {
}
// DependsOn returns nil, the core DSL has no dependency.
-func (r *RootExpr) DependsOn() []eval.Root { return nil }
+func (*RootExpr) DependsOn() []eval.Root { return nil }
// Packages returns the Go import path to this and the dsl packages.
-func (r *RootExpr) Packages() []string {
+func (*RootExpr) Packages() []string {
return []string{
"goa.design/goa/v3/expr",
"goa.design/goa/v3/dsl",
@@ -213,7 +213,7 @@ func (r *RootExpr) HTTPServiceFor(s *ServiceExpr) *HTTPServiceExpr {
}
// EvalName is the name of the DSL.
-func (r *RootExpr) EvalName() string {
+func (*RootExpr) EvalName() string {
return "design"
}
diff --git a/vendor/goa.design/goa/v3/expr/server.go b/vendor/goa.design/goa/v3/expr/server.go
index aa08d8c097..cf5f742acc 100644
--- a/vendor/goa.design/goa/v3/expr/server.go
+++ b/vendor/goa.design/goa/v3/expr/server.go
@@ -247,7 +247,7 @@ func (h *HostExpr) URIString(u URIExpr) (string, error) {
if def == nil {
def = v.Attribute.Validation.Values[0]
}
- uri = strings.Replace(uri, fmt.Sprintf("{%s}", p), fmt.Sprintf("%v", def), -1)
+ uri = strings.ReplaceAll(uri, fmt.Sprintf("{%s}", p), fmt.Sprintf("%v", def))
}
}
}
diff --git a/vendor/goa.design/goa/v3/expr/service.go b/vendor/goa.design/goa/v3/expr/service.go
index b78ba0751a..dd8f726d2c 100644
--- a/vendor/goa.design/goa/v3/expr/service.go
+++ b/vendor/goa.design/goa/v3/expr/service.go
@@ -100,7 +100,7 @@ func (s *ServiceExpr) Finalize() {
func (e *ErrorExpr) Validate() error {
verr := new(eval.ValidationErrors)
var errField string
- walkAttribute(e.AttributeExpr, func(name string, att *AttributeExpr) error {
+ walkAttribute(e.AttributeExpr, func(name string, att *AttributeExpr) error { // nolint: errcheck
if _, ok := att.Meta["struct:error:name"]; ok {
if errField != "" {
verr.Add(e, "duplicate error names in type %q", e.AttributeExpr.Type.Name())
diff --git a/vendor/goa.design/goa/v3/expr/testing.go b/vendor/goa.design/goa/v3/expr/testing.go
index f88c599b14..609cd18fad 100644
--- a/vendor/goa.design/goa/v3/expr/testing.go
+++ b/vendor/goa.design/goa/v3/expr/testing.go
@@ -68,7 +68,7 @@ func Diff(t *testing.T, s1, s2 string) string {
defer os.Remove(right)
cmd := exec.Command("diff", left, right)
diffb, _ := cmd.CombinedOutput()
- return strings.Replace(string(diffb), "\t", " ␉ ", -1)
+ return strings.ReplaceAll(string(diffb), "\t", " ␉ ")
}
// CreateTempFile creates a temporary file and writes the given content.
@@ -95,8 +95,12 @@ func setupDSLRun() {
eval.Reset()
Root = new(RootExpr)
Root.GeneratedTypes = &GeneratedRoot{}
- eval.Register(Root)
- eval.Register(Root.GeneratedTypes)
+ if err := eval.Register(Root); err != nil {
+ panic(err)
+ }
+ if err := eval.Register(Root.GeneratedTypes); err != nil {
+ panic(err)
+ }
Root.API = NewAPIExpr("test api", func() {})
Root.API.Servers = []*ServerExpr{Root.API.DefaultServer()}
}
diff --git a/vendor/goa.design/goa/v3/expr/types.go b/vendor/goa.design/goa/v3/expr/types.go
index c0795086f1..eccbad5784 100644
--- a/vendor/goa.design/goa/v3/expr/types.go
+++ b/vendor/goa.design/goa/v3/expr/types.go
@@ -271,10 +271,10 @@ func IsAlias(dt DataType) bool {
// Equal compares the types recursively and returns true if they are equal. Two
// types are equal if:
//
-// - both types have the same kind
-// - array types have elements whose types are equal
-// - map types have keys and elements whose types are equal
-// - objects have the same attribute names and the attribute types are equal
+// - both types have the same kind
+// - array types have elements whose types are equal
+// - map types have keys and elements whose types are equal
+// - objects have the same attribute names and the attribute types are equal
//
// Note: calling Equal is not equivalent to evaluating dt.Hash() == dt2.Hash()
// as the former may return true for two user types with different names and
@@ -381,10 +381,10 @@ func (p Primitive) Hash() string {
}
// Kind implements DataKind.
-func (a *Array) Kind() Kind { return ArrayKind }
+func (*Array) Kind() Kind { return ArrayKind }
// Name returns the type name.
-func (a *Array) Name() string {
+func (*Array) Name() string {
return "array"
}
@@ -502,10 +502,10 @@ func (o *Object) Rename(n, m string) {
}
// Kind implements DataKind.
-func (o *Object) Kind() Kind { return ObjectKind }
+func (*Object) Kind() Kind { return ObjectKind }
// Name returns the type name.
-func (o *Object) Name() string { return "object" }
+func (*Object) Name() string { return "object" }
// Hash returns a unique hash value for o.
func (o *Object) Hash() string {
@@ -524,7 +524,7 @@ func (o *Object) Merge(other *Object) *Object {
}
// IsCompatible returns true if o describes the (Go) type of val.
-func (o *Object) IsCompatible(val any) bool {
+func (*Object) IsCompatible(val any) bool {
k := reflect.TypeOf(val).Kind()
return k == reflect.Map || k == reflect.Struct
}
@@ -541,10 +541,10 @@ func (o *Object) Example(r *ExampleGenerator) any {
}
// Kind implements DataKind.
-func (m *Map) Kind() Kind { return MapKind }
+func (*Map) Kind() Kind { return MapKind }
// Name returns the type name.
-func (m *Map) Name() string { return "map" }
+func (*Map) Name() string { return "map" }
// Hash returns a unique hash value for m.
func (m *Map) Hash() string {
@@ -614,7 +614,7 @@ func (m MapVal) ToMap() map[any]any {
}
// Kind implements DataKind.
-func (u *Union) Kind() Kind { return UnionKind }
+func (*Union) Kind() Kind { return UnionKind }
// Name returns the type name.
func (u *Union) Name() string { return u.TypeName }
@@ -647,10 +647,9 @@ func (u *Union) Example(r *ExampleGenerator) any {
// array or map types. This is useful in reporting types in error messages,
// examples of qualified type names:
//
-// "array