gocart

Documentation

Index

• func AssignPrimitive(value reflect.Value, str string) error
• func AssignPrimitives(value reflect.Value, strs []string) error
• func EncodePrimitive(value reflect.Value) (string, error)
• func EncodePrimitives(value reflect.Value) ([]string, error)
• type BinarySerializer
  • func (receiver *BinarySerializer) Deserialize(data []byte, headers http.Header) (*[]byte, error)
  • func (receiver *BinarySerializer) Serialize(body *[]byte, headers http.Header) ([]byte, error)
  • func (receiver *BinarySerializer) Type() *goflag.Type
• type Cart
  • func A[TInput any, TOutput any](h CartFunc[TInput, TOutput]) Cart
  • func I[TInput any, TOutput any](input Serializer[TInput], h CartFunc[TInput, TOutput]) Cart
  • func IO[TInput any, TOutput any](input Serializer[TInput], output Serializer[TOutput], ...) Cart
  • func O[TInput any, TOutput any](output Serializer[TOutput], h CartFunc[TInput, TOutput]) Cart
• type CartFunc
• type CartInformation
  • func (actor *CartInformation) WithDescription(description string) *CartInformation
  • func (actor *CartInformation) WithHidden(hidden bool) *CartInformation
  • func (actor *CartInformation) WithSummary(summary string) *CartInformation
• type Decoder
  • func NewFormDecorder(request *http.Request) Decoder
  • func NewHeaderDecoder(request *http.Request) Decoder
  • func NewPathDecoder(request *http.Request) Decoder
  • func NewQueryDecoder(request *http.Request) Decoder
• type DecoderFactory
• type Encoder
  • func NewHeaderEncoder(writer http.ResponseWriter) Encoder
• type EncoderFactory
• type HeaderDecoder
  • func (dec *HeaderDecoder) Decode(field reflect.StructField) ([]string, error)
• type HeaderEncoder
  • func (enc *HeaderEncoder) Encode(value reflect.Value, field reflect.StructField) error
• type HeaderWriter
• type MarshalSerializer
  • func (j *MarshalSerializer[T]) Deserialize(data []byte, headers http.Header) (*T, error)
  • func (j *MarshalSerializer[T]) Serialize(body *T, headers http.Header) ([]byte, error)
  • func (j *MarshalSerializer[T]) Type() *goflag.Type
• type PathDecoder
  • func (dec *PathDecoder) Decode(field reflect.StructField) ([]string, error)
• type Request
  • func (r *Request[TBody]) Body() *TBody
• type Serializer
  • func Binary(contentType ...string) Serializer[[]byte]
  • func Json[T any]() Serializer[T]
  • func Xml[T any]() Serializer[T]
  • func Yaml[T any]() Serializer[T]
• type UrlValuesDecoder
  • func (dec *UrlValuesDecoder) Decode(field reflect.StructField) ([]string, error)

Functions

func AssignPrimitive

func AssignPrimitive(value reflect.Value, str string) error

AssignPrimitive is used when decoding, to convert the str to the appropriate primitive and then assign it to value

func AssignPrimitives

func AssignPrimitives(value reflect.Value, strs []string) error

AssignPrimitives is used when decoding, to convert the strs to the appropriate primitives and then assign them to value

func EncodePrimitive

func EncodePrimitive(value reflect.Value) (string, error)

EncodePrimitive encodes the value of value as a string

func EncodePrimitives

func EncodePrimitives(value reflect.Value) ([]string, error)

EncodePrimitives encodes the value(s) of value as a string and if multiple separates them by a "," (see url.Values)

Types

type BinarySerializer

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

func (*BinarySerializer) Deserialize

func (receiver *BinarySerializer) Deserialize(data []byte, headers http.Header) (*[]byte, error)

func (*BinarySerializer) Serialize

func (receiver *BinarySerializer) Serialize(body *[]byte, headers http.Header) ([]byte, error)

func (*BinarySerializer) Type

func (receiver *BinarySerializer) Type() *goflag.Type

type Cart

type Cart interface {
	goflag.EndpointFlag
	WithInfo(fn func(info *CartInformation)) Cart
}

Cart represents a gotrac.EndpointFlag that automatically can (de)serialize the request/response

func A

func A[TInput any, TOutput any](h CartFunc[TInput, TOutput]) Cart

A is used to define a Cart that does NOT deserialize it's input and does NOT serialize the output.

However, TInput and TOutput can still be specified to allow for meta-fields!

func I

func I[TInput any, TOutput any](input Serializer[TInput], h CartFunc[TInput, TOutput]) Cart

I is used to define a Cart that deserializes it's input but does NOT serialize the output.

However, TOutput can still be specified to allow for meta-fields!

func IO

func IO[TInput any, TOutput any](input Serializer[TInput], output Serializer[TOutput], h CartFunc[TInput, TOutput]) Cart

IO is used to define a Cart that deserializes it's input and serializes the output.

func O

func O[TInput any, TOutput any](output Serializer[TOutput], h CartFunc[TInput, TOutput]) Cart

O is used to define a Cart that does NOT deserialize it's input but does serialize the output.

However, TInput can still be specified to allow for meta-fields!

type CartFunc

type CartFunc[TInput any, TOutput any] func(request *Request[TInput], writer HeaderWriter) (*TOutput, error)

CartFunc is the actual handler that gets the deserialized request (and a HeaderWriter) and returns the response body that will then be serialized by the cart.

type CartInformation

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

func (*CartInformation) WithDescription

func (actor *CartInformation) WithDescription(description string) *CartInformation

func (*CartInformation) WithHidden

func (actor *CartInformation) WithHidden(hidden bool) *CartInformation

func (*CartInformation) WithSummary

func (actor *CartInformation) WithSummary(summary string) *CartInformation

type Decoder

type Decoder interface {
	Decode(field reflect.StructField) ([]string, error)
}

Decoder reads data from HTTP headers, the query, formdata, etc. The returned strings are converted to the proper primitive types. If the receiving field is not an array, but multiple values are provided the first one will be used

func NewFormDecorder

func NewFormDecorder(request *http.Request) Decoder

func NewHeaderDecoder

func NewHeaderDecoder(request *http.Request) Decoder

func NewPathDecoder

func NewPathDecoder(request *http.Request) Decoder

func NewQueryDecoder

func NewQueryDecoder(request *http.Request) Decoder

type DecoderFactory

type DecoderFactory func(request *http.Request) Decoder

type Encoder

type Encoder interface {
	Encode(value reflect.Value, field reflect.StructField) error
}

Encoder sets data on the return headers and cookies

func NewHeaderEncoder

func NewHeaderEncoder(writer http.ResponseWriter) Encoder

type EncoderFactory

type EncoderFactory func(writer http.ResponseWriter) Encoder

type HeaderDecoder

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

func (*HeaderDecoder) Decode

func (dec *HeaderDecoder) Decode(field reflect.StructField) ([]string, error)

type HeaderEncoder

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

func (*HeaderEncoder) Encode

func (enc *HeaderEncoder) Encode(value reflect.Value, field reflect.StructField) error

type HeaderWriter

type HeaderWriter interface {
	// Header returns the meta map that will be sent by
	// [ResponseWriter.WriteHeader]. The [Header] map also is the mechanism with which
	// [Handler] implementations can set HTTP trailers.
	//
	// Changing the meta map after a call to [ResponseWriter.WriteHeader] (or
	// [ResponseWriter.Write]) has no effect unless the HTTP status code was of the
	// 1xx class or the modified headers are trailers.
	//
	// There are two ways to set Trailers. The preferred way is to
	// predeclare in the headers which trailers you will later
	// send by setting the "Trailer" meta to the names of the
	// trailer keys which will come later. In This case, those
	// keys of the Header map are treated as if they were
	// trailers. See the example. The second way, for trailer
	// keys not known to the [Handler] until after the first [ResponseWriter.Write],
	// is to prefix the [Header] map keys with the [TrailerPrefix]
	// constant value.
	//
	// To suppress automatic response headers (such as "Date"), set
	// their value to nil.
	Header() http.Header

	// WriteHeader sends an HTTP response meta with the provided
	// status code.
	//
	// If WriteHeader is not called explicitly, the first call to Write
	// will trigger an implicit WriteHeader(gocart.StatusOK).
	// Thus explicit calls to WriteHeader are mainly used to
	// send error codes or 1xx informational responses.
	//
	// The provided code must be a valid HTTP 1xx-5xx status code.
	// Any number of 1xx headers may be written, followed by at most
	// one 2xx-5xx meta. 1xx headers are sent immediately, but 2xx-5xx
	// headers may be buffered. Use the Flusher interface to send
	// buffered data. The meta map is cleared when 2xx-5xx headers are
	// sent, but not with 1xx headers.
	//
	// The server will automatically send a 100 (Continue) meta
	// on the first read from the request body if the request has
	// an "Expect: 100-continue" meta.
	WriteHeader(statusCode int)
}

HeaderWriter allows a CartFunc to write and read to the response header without being able to write the body. This helps to ensure the proper write flow, i.e. headers can not be written after the body.

type MarshalSerializer

type MarshalSerializer[T any] struct {
	// contains filtered or unexported fields
}

MarshalSerializer implements the Serializer interface using the go-convention marshal/unmarshal functions. It is for example used for Json, Yaml and Xml

func (*MarshalSerializer[T]) Deserialize

func (j *MarshalSerializer[T]) Deserialize(data []byte, headers http.Header) (*T, error)

func (*MarshalSerializer[T]) Serialize

func (j *MarshalSerializer[T]) Serialize(body *T, headers http.Header) ([]byte, error)

func (*MarshalSerializer[T]) Type

func (j *MarshalSerializer[T]) Type() *goflag.Type

type PathDecoder

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

func (*PathDecoder) Decode

func (dec *PathDecoder) Decode(field reflect.StructField) ([]string, error)

type Request

type Request[TBody any] struct {
	http.Request
	// contains filtered or unexported fields
}

Request is a http.Request that also contains the already deserialized body, which can then be retrieved by calling Body().

func (*Request[TBody]) Body

func (r *Request[TBody]) Body() *TBody

Body returns a pointer to the already deserialized body.

type Serializer

type Serializer[T any] interface {
	Serialize(body *T, headers http.Header) ([]byte, error)
	Deserialize(data []byte, headers http.Header) (*T, error)
	Type() *goflag.Type
}

Serializer determines how the body of the http.Request should be decoded. Common types can be constructed using Json, Yaml, Xml, Binary, etc. However, the Serializer can also be implemented by you!

func Binary

func Binary(contentType ...string) Serializer[[]byte]

Binary Serializer just passes through the body, but it does allow you to set the MIME type yourself!

func Json

func Json[T any]() Serializer[T]

Json Serializer to decode the http.Request`s body

func Xml

func Xml[T any]() Serializer[T]

Xml Serializer to decode the http.Request`s body

func Yaml

func Yaml[T any]() Serializer[T]

Yaml Serializer to decode the http.Request`s body

type UrlValuesDecoder

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

func (*UrlValuesDecoder) Decode

func (dec *UrlValuesDecoder) Decode(field reflect.StructField) ([]string, error)