http

type DecodeOptions ¶

type DecodeOptions struct {
	// MaxBodyBytes defaults to 1 MiB. The body is read with a bounded allocation.
	MaxBodyBytes int64
	// Unknown fields are rejected by default; opt in to compatibility if needed.
	AllowUnknownFields bool
}

type Error ¶

type Error struct {
	Status  int               `json:"-"`
	Code    string            `json:"code"`
	Message string            `json:"message"`
	Fields  map[string]string `json:"fields,omitempty"`
	// contains filtered or unexported fields
}

Error describes a public HTTP error. Its status and internal cause are not serialized, and domain errors need not import this package.

func NewError(status int, code, message string) *Error

func (e *Error) Error() string

func (e *Error) Unwrap() error

func (e *Error) WithCause(cause error) *Error

func (e *Error) WithFields(fields map[string]string) *Error

func (e *Error) Write(w stdhttp.ResponseWriter) error

type ErrorMapper ¶

type ErrorMapper interface {
	Map(error) *Error
	Write(stdhttp.ResponseWriter, error) error
}

ErrorMapper is the contract used by HTTP consumers. Implementations map application errors and write their public response without exposing causes.

type HandlerAdapter ¶ added in v0.1.3

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

HandlerAdapter maps returned errors and logs failures at the net/http boundary. Wrap returns an ordinary HandlerFunc, composable with native middleware.

func NewHandlerAdapter(mapper ErrorMapper, logger logging.Logger) *HandlerAdapter

func (a *HandlerAdapter) Wrap(handler func(stdhttp.ResponseWriter, *stdhttp.Request) error) stdhttp.HandlerFunc

type Mapper ¶

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

func NewMapper(rules ...Rule) *Mapper

func (m *Mapper) Map(err error) *Error

func (m *Mapper) Write(w stdhttp.ResponseWriter, err error) error

type Response ¶

type Response[T any] struct {
	Status  int
	Headers stdhttp.Header
	Body    T
}

func Created[T any](location string, body T) Response[T]

func JSON[T any](status int, body T) Response[T]

func NoContent() Response[struct{}]

func OK[T any](body T) Response[T]

func (r Response[T]) Write(w stdhttp.ResponseWriter) error

type Rule ¶

type Rule func(error) *Error

Rule returns nil when it does not match. Rules must be safe for concurrent use.

func As[T error](mapError func(T) *Error) Rule

func Is(target error, response *Error) Rule