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 CodecDefault struct {
	Serializer interface {
		codec.Codec
		codec.ListDecoderMaker
	}
	MediaType string
}

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

type FormURLEncodedCodec struct{}

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 Mapper[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[ENT, ID any] struct {
	// BaseURL [required] is the url base that the rest client will use to
	BaseURL string
	// HTTPClient [optional] will be used to make the http requests from the rest client.
	//
	// default: httpkit.DefaultRestClientHTTPClient
	HTTPClient *http.Client
	// MediaType [optional] is used in the related headers such as Content-Type and Accept.
	//
	// default: httpkit.DefaultSerializer.MIMEType
	MediaType string
	// Mapping [optional] is used if the ENT must be mapped into a DTO type prior to serialization.
	//
	// default: ENT type is used as the DTO type.
	Mapping dtokit.Mapper[ENT]
	// Serializer [optional] is used for the serialization process with DTO values.
	//
	// default: DefaultSerializers will be used to find a matching serializer for the given media type.
	Serializer RestClientSerializer
	// IDConverter [optional] is used to convert the ID value into a string format,
	// that can be used to path encode for requests.
	//
	// default: httpkit.IDConverter[ID]
	IDConverter idConverter[ID]
	// LookupID [optional] is used to lookup the ID value in an ENT value.
	//
	// default: extid.Lookup[ID, ENT]
	LookupID extid.LookupIDFunc[ENT, ID]
	// WithContext [optional] allows you to add data to the context for requests.
	// If you need to select a RESTful subresource and return it as a RestClient,
	// you can use this function to add the selected resource's path parameter
	// to the context using httpkit.WithPathParam.
	//
	// default: ignored
	WithContext func(context.Context) context.Context
	// PrefetchLimit is used when a methor requires fetching entities ahead.
	// If set to -1, then prefetch is disabled.
	//
	// default: 20
	PrefetchLimit int
}

type RestClientSerializer interface {
	codec.Codec
	codec.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) (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, 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) 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 dtokit.Mapper[Entity]

	// MappingForMediaType defines a per MIMEType Mapping, that takes priority over Mapping
	MappingForMediaType map[string]dtokit.Mapper[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

	// IDAccessor [optional] tells how to look up or set the Entity's ID.
	//
	// Default: extid.Lookup / extid.Set
	IDAccessor extid.Accessor[Entity, ID]

	// 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 {
	codec.Codec
}

type StringID[ID ~string] struct{}