httpkit

type AccessLog struct {
	Next http.Handler

	AdditionalLoggingDetail func(w http.ResponseWriter, r *http.Request) logging.Detail
}

type ClientErrUnexpectedResponse struct {
	StatusCode int
	Body       string
	URL        *url.URL
}

type DTOMapping[Entity, DTO any] struct {
	// ToEnt is an optional function to describe how to map a DTO into an Entity.
	//
	// default: dtokit.Map[Entity, DTO](...)
	ToEnt func(ctx context.Context, dto DTO) (Entity, error)
	// ToDTO is an optional function to describe how to map an Entity into a DTO.
	//
	// default: dtokit.Map[DTO, Entity](...)
	ToDTO func(ctx context.Context, ent Entity) (DTO, error)
}

type ErrorHandler interface {
	HandleError(w http.ResponseWriter, r *http.Request, err error)
}

type IDConverter[ID any] struct {
	Format func(ID) (string, error)
	Parse  func(string) (ID, error)
}

type IDInContext[CtxKey, EntityIDType any] struct{}

type IntID[ID ~int] struct{}

type Mapping[Entity any] interface {
	// contains filtered or unexported methods
}

type MiddlewareFactoryFunc func(next http.Handler) http.Handler

type Multiplexer interface {
	Handle(pattern string, handler http.Handler)
}

type RestClient[Entity, ID any] struct {
	BaseURL     string
	HTTPClient  *http.Client
	MIMEType    string
	Mapping     Mapping[Entity]
	Serializer  RestClientSerializer
	IDConverter idConverter[ID]
	LookupID    crud.LookupIDFunc[Entity, ID]
}

type RestClientSerializer interface {
	serializers.Serializer
	serializers.ListDecoderMaker
}

type RestResource[Entity, ID any] struct {
	// Create will create a new entity in the restful resource.
	// 		POST /
	Create func(ctx context.Context, ptr *Entity) error
	// Index will return the entities, optionally filtered with the query argument.
	//		GET /
	Index func(ctx context.Context, query url.Values) (iterators.Iterator[Entity], error)
	// Show will return a single entity, looked up by its ID.
	// 		GET /:id
	Show func(ctx context.Context, id ID) (ent Entity, found bool, err error)
	// Update will update/replace an entity with the new state.
	// 		PUT   /:id - update/replace
	// 		PATCH /:id - partial update (WIP)
	Update func(ctx context.Context, id ID, ptr *Entity) error
	// Destroy will delete an entity, identified by its id.
	// 		 Delete /:id
	Destroy func(ctx context.Context, id ID) error
	// DestroyAll will delete all entity.
	// 		 Delete /
	DestroyAll func(ctx context.Context, query url.Values) error

	// Serialization is responsible to serialize and unserialize dtokit.
	// JSON, line separated JSON stream and FormUrlencoded formats are supported out of the box.
	//
	// Serialization is an optional field.
	// Unless you have specific needs in serialization, don't configure it.
	Serialization RestResourceSerialization[Entity, ID]

	// Mapping is the primary Entity to DTO mapping configuration.
	Mapping Mapping[Entity]

	// MappingForMIME defines a per MIMEType Mapping, that takes priority over Mapping
	MappingForMIME map[string]Mapping[Entity]

	// ErrorHandler is used to handle errors from the request, by mapping the error value into an error DTOMapping.
	ErrorHandler ErrorHandler

	// IDContextKey is an optional field used to store the parsed ID from the URL in the context.
	//
	// Default: IDContextKey[Entity, ID]{}
	IDContextKey any

	// SubRoutes is an http.Handler that will receive resource-specific requests.
	// SubRoutes is optional.
	//
	// The http.Request.Context will contain the parsed ID from the request path,
	// and can be accessed with the IDContextKey.
	//
	// Example paths
	// 		/plural-resource-identifier-name/:id/sub-routes
	// 		/users/42/status
	// 		/users/42/jobs/13
	//
	// Request paths will be stripped from their prefix.
	// For example, "/users/42/jobs" will end up as "/jobs".
	SubRoutes http.Handler

	// BodyReadLimit is the max bytes that the handler is willing to read from the request body.
	//
	// The default value is DefaultBodyReadLimit, which is preset to 16MB.
	BodyReadLimit iokit.ByteSize
}

type RestResourceSerialization[Entity, ID any] struct {
	Serializers map[string]Serializer
	IDConverter idConverter[ID]
}

type RetryRoundTripper struct {
	// Transport specifies the mechanism by which individual
	// HTTP requests are made.
	//
	// Default: http.DefaultTransport
	Transport http.RoundTripper
	// RetryStrategy will be used to evaluate if a new retry attempt should be done.
	//
	// Default: retry.ExponentialBackoff
	RetryStrategy retry.Strategy[retry.FailureCount]
	// OnStatus is an [OPTIONAL] configuration field that could contain whether a certain http status code should be retried or not.
	// The RetryRoundTripper has a default behaviour about which status code can be retried, and this option can override that.
	OnStatus map[int]bool
}

type RoundTripperFactoryFunc func(next http.RoundTripper) http.RoundTripper

type RoundTripperFunc func(request *http.Request) (*http.Response, error)

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

type Serializer interface {
	serializers.Serializer
}

type SerializerDefault struct {
	Serializer interface {
		serializers.Serializer
		serializers.ListDecoderMaker
	}
	MIMEType string
}

type StringID[ID ~string] struct{}