ale

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

type ErrorReporter func(w http.ResponseWriter, r *http.Request, err error)

type Handler interface {
	// ServeHTTPE serves the same purpose as http.Handler's ServeHTTP, except
	// that it may return an error. The function should _either_ write to
	// http.ResponseWriter _or_ return an error.
	ServeHTTPE(http.ResponseWriter, *http.Request) error
}

type HandlerFunc func(http.ResponseWriter, *http.Request) error

type LogContext struct {

	// Request is the client request.
	Request *http.Request

	// StatusCode is the HTTP status code sent to the client.
	StatusCode int
	// ResponseHeader is the list of header values sent to the client.
	ResponseHeader http.Header
	// ResponseHeader is the list of trailer values sent to the client.
	ResponseTrailer http.Header
	// ResponseBytes is the number of bytes written in the response body.
	ResponseBytes int64
	// RequestBytes is the number of bytes read from the request body. This
	// can differ from the Content-Length value if reading is not completed, or
	// in case Content-Length is unset.
	RequestBytes int64

	// StartTime is the time the request was received by the server
	StartTime time.Time
	// ElapsedTime is the duration it took to serve the request
	ElapsedTime time.Duration

	// Error is the error, if any, returned from the handler/middlware chain.
	Error error

	// Data is a collection of arbitrary request-scoped data to be logged.
	// Add to this by calling LogData.
	Data map[string]interface{}
	// contains filtered or unexported fields
}

type Middleware func(Handler) Handler

type Router interface {
	http.Handler
	Handler

	// EarlyUse registers middlewares in the call chain before the error
	// reporter or logger. It is intended for setting metadata, such as trace
	// IDs, that are necessary to properly handle errors or log requests.
	//
	// Calling EarlyUse on a sub-router will panic.
	EarlyUse(middlewares ...Middleware)
	// ErrorReporter defines an error reporter at the top of the call chain.
	// The error reporter should turn an error value into an HTTP response to
	// be consumed by the client.
	//
	// It is not uncommon to also want to set an error handler further down the
	// call chain, to consume additional information (such as authenticated user
	// trace IDs, etc) that may be added to the context later in the middleware
	// call chain. It is therefore safe to use ErrorReporter and also call
	// Use(ale.ErrorReporter(<your func>).Middleware).  The ErrorReporter type
	// ensures that any given error is not reported more than once.
	ErrorReporter(ErrorReporter)
	Logger(func(*LogContext))

	// Use appends one or more middlewares onto the Router stack.
	Use(middlewares ...Middleware)

	// With adds inline middlewares for an endpoint handler.
	With(middlewares ...Middleware) Router

	// Group adds a new inline-Router along the current routing
	// path, with a fresh middleware stack for the inline-Router.
	Group() Router

	// Route mounts a sub-Router along a `pattern“ string.
	Route(pattern string) Router

	// Mount attaches another Handler along ./pattern/*
	Mount(pattern string, h Handler)

	// Handle and HandleFunc adds routes for `pattern` that matches
	// all HTTP methods.
	Handle(pattern string, h Handler)
	HandleFunc(pattern string, h HandlerFunc)

	// Method and MethodFunc adds routes for `pattern` that matches
	// the `method` HTTP method.
	Method(method, pattern string, h Handler)
	MethodFunc(method, pattern string, h HandlerFunc)

	// HTTP-method routing along `pattern`
	Connect(pattern string, h HandlerFunc)
	Delete(pattern string, h HandlerFunc)
	Get(pattern string, h HandlerFunc)
	Head(pattern string, h HandlerFunc)
	Options(pattern string, h HandlerFunc)
	Patch(pattern string, h HandlerFunc)
	Post(pattern string, h HandlerFunc)
	Put(pattern string, h HandlerFunc)
	Trace(pattern string, h HandlerFunc)

	// NotFound defines a handler to respond whenever a route could
	// not be found.
	NotFound(h HandlerFunc)

	// MethodNotAllowed defines a handler to respond whenever a method is
	// not allowed.
	MethodNotAllowed(h HandlerFunc)
}

type UsedWriter interface {
	http.ResponseWriter
	Used() bool
}

type WrapFunc func(http.ResponseWriter, *http.Request)