midl

type Adapter interface {
	http.Handler

	// EmptyHandler registers a handler for empty response
	// bodies.
	//
	// Defaults to an empty byte array
	EmptyHandler(EmptyHandler) Adapter

	// Content-Type sets the default content type header.
	ContentType(string) Adapter

	// ErrorSerializer registers a handler for serializing
	// errors.
	ErrorSerializer(ErrorSerializer) Adapter

	// Serializer registers the default body serializer.
	Serializer(Serializer) Adapter

	// AddHandlers appends handlers to the list of Middleware
	// handlers.
	AddHandlers(...Middleware) Adapter

	// SetHandlers set and/or overwrite the current list of
	// Middleware handlers.
	SetHandlers(...Middleware) Adapter
}

type BodyProcessor interface {

	// Process is used to handle some work which requires a
	// request body.  This function is meant to be used with
	// Request.ProcessBody() which allows chaining various
	// operations, such as validation, deserialization, etc...
	Process([]byte) error
}

type BodyProcessorFunc func([]byte) error

type EmptyHandler interface {

	// Handle will be called in the event that a response body
	// is nil.
	Handle(Request, Response) []byte
}

type EmptyHandlerFunc func(Request, Response) []byte

type ErrorSerializer interface {

	// Serialize is used to serialize the given error into an
	// array of bytes.  The HTTP request and response are
	// provided for context and to allow overriding/setting a
	// response status code or headers.
	Serialize(error, Request, Response) []byte
}

type ErrorSerializerFunc func(error, Request, Response) []byte

type Middleware interface {

	// Handle handles an HTTP request.
	//
	// If Handle returns a non-nil value, this signals to the
	// midl.Adapter that this request has been processed.
	Handle(Request) Response
}

type MiddlewareFunc func(Request) Response

type Request interface {
	// Header gets the first header stored at the given key.
	Header(key string) (value string, ok bool)

	// Headers gets all headers stored at the given key.
	Headers(key string) (values []string, ok bool)

	// Body retrieves the request body bytes.
	//
	// In the event of a read error, returns nil; the error
	// will be available by calling the Error method.
	//
	// Multiple calls will only read the http.Request.Body
	// reader once.
	Body() []byte

	// Host retrieves the host string from the request.
	Host() string

	// Parameter get the query parameter stored at a given
	// key.
	Parameter(key string) (value string, ok bool)

	// Parameters gets all query parameters stored at a given
	// key.
	Parameters(key string) (values []string, ok bool)

	// RawRequest retrieves the raw Go standard library
	// request.
	//
	// Warning: Modifying the raw http.Request may impact the
	// output of other Request methods.
	RawRequest() *http.Request

	// Error retrieves the last error (if any) encountered by
	// method calls to Request.
	// If no error is present, returns nil.
	Error() error

	// ProcessBody runs the given BodyProcessor against the
	// body bytes of this request.
	//
	// Errors emitted by the body processor will be
	// retrievable from the Error method.
	//
	// Calls to this method will do nothing if an error has
	// been previously encountered.
	ProcessBody(BodyProcessor) Request

	// AdditionalContext returns a map for use in assigning
	// additional arbitrary context data to a request.
	AdditionalContext() map[interface{}]interface{}
}

type Response interface {

	// Body returns the body (if any) stored on the HTTP
	// response.
	Body() interface{}

	// Code returns the HTTP status code from the HTTP
	// response.
	Code() int

	// Error returns the error (if any) stored on the HTTP
	// response.
	Error() error

	// Header retrieves a header stored header value by key.
	Header(key string) string

	// Headers retrieves a slice of stored headers values by
	// key.
	Headers(key string) []string

	// SetBody stores the given value as the body value for
	// this response.
	SetBody(any interface{}) Response

	// SetCode stores the given value as the HTTP status code
	// for this response.
	SetCode(code int) Response

	// SetError stores the given value as the error value for
	// this response.
	SetError(error) Response

	// AddHeader creates or appends to the header values for
	// this response.
	AddHeader(key, value string) Response

	// AddedHeaders creates or appends a list of headers to
	// this response.
	AddHeaders(key string, value []string) Response

	// SetHeader creates or overwrites a header on this
	// response.
	SetHeader(key, value string) Response

	// SetHeaders creates or overwrites a list of headers on
	// this response.
	SetHeaders(key string, values []string) Response

	// RawHeaders grants access to the internal http.Header
	// map.
	RawHeaders() http.Header

	// Callback allows providing a request completion callback
	// function that will be called asynchronously on request
	// completion.
	Callback(func()) Response

	// Callbacks returns the list of set callbacks on the
	// Response object.
	Callbacks() []func()
}

type Serializer interface {

	// Serialize is used to serialize the response body passed
	// as its input parameter into a byte array. If the
	// serialization fails the returned error will be passed
	// to the Adapter's ErrorSerializer.
	Serialize(interface{}) ([]byte, error)
}

type SerializerFunc func(interface{}) ([]byte, error)