httpclient

type AfterHook interface {
	ResponseFunc() httptransport.ClientResponseFunc
}

type BeforeHook interface {
	RequestFunc() httptransport.RequestFunc
}

type Client interface {
	// Execute send the provided request and parse the response using provided ResponseOptions
	// When using default decoding function:
	// 		- it returns non-nil Response only if the response has 2XX status code
	// 		- it returns non-nil error for 4XX, 5XX status code or any other type of errors
	// 		- the returned error can be casted to *Error
	Execute(ctx context.Context, request *Request, opts ...ResponseOptions) (*Response, error)

	// WithService create a client with specific service with given instance selectors.
	// The returned client is responsible to track service instance changes with help of discovery package,
	// and to perform load-balancing and retrying.
	// The returned client is goroutine-safe and can be reused
	WithService(service string, selectors ...discovery.InstanceMatcher) (Client, error)

	// WithBaseUrl create a client with specific base URL.
	// The returned client is responsible to perform retrying.
	// The returned client is goroutine-safe and can be reused
	WithBaseUrl(baseUrl string) (Client, error)

	// WithConfig create a shallow copy of the client with specified config.
	// Service (with LB) or BaseURL cannot be changed with this method.
	// If non-primitive field of provided config is zero value, this value is not applied.
	// The returned client is goroutine-safe and can be reused
	WithConfig(config *ClientConfig) Client
}

type ClientConfig struct {
	HTTPClient  *http.Client // underlying http.Client to use
	BeforeHooks []BeforeHook
	AfterHooks  []AfterHook
	MaxRetries  int // negative value means no retry
	Timeout     time.Duration
	Logger      log.ContextualLogger
	Logging     LoggingConfig
}

type ClientCustomizer interface {
	Customize(opt *ClientOption)
}

type ClientCustomizerFunc func(opt *ClientOption)

type ClientOption struct {
	ClientConfig
	DefaultSelector    discovery.InstanceMatcher
	DefaultBeforeHooks []BeforeHook
	DefaultAfterHooks  []AfterHook
}

type ClientOptions func(opt *ClientOption)

type ConfigurableAfterHook interface {
	WithConfig(cfg *ClientConfig) AfterHook
}

type ConfigurableBeforeHook interface {
	WithConfig(cfg *ClientConfig) BeforeHook
}

type EndpointFactory func(instDesp interface{}) (endpoint.Endpoint, error)

type Endpointer interface {
	sd.Endpointer
	WithConfig(config *EndpointerConfig) Endpointer
}

type EndpointerConfig struct {
	EndpointFactory EndpointFactory
	Selector        discovery.InstanceMatcher
	Logger          log.ContextualLogger
}

type EndpointerOption struct {
	ServiceName       string
	EndpointFactory   EndpointFactory
	Selector          discovery.InstanceMatcher
	InvalidateOnError bool
	InvalidateTimeout time.Duration
	Logger            log.ContextualLogger
}

type EndpointerOptions func(*EndpointerOption)

type Error struct {
	CodedError
	Response *ErrorResponse
}

type ErrorResponse struct {
	http.Response
	RawBody []byte
	Body    ErrorResponseBody
}

type ErrorResponseBody interface {
	Error() string
	Message() string
	Details() map[string]string
}

type HttpClientProperties struct {
	MaxRetries int              `json:"max-retries"` // negative value means no retry
	Timeout    utils.Duration   `json:"timeout"`
	Logger     LoggerProperties `json:"logger"`
}

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

type LogDetailsLevel int

type LoggerProperties struct {
	Level           log.LoggingLevel          `json:"level"`
	DetailsLevel    LogDetailsLevel           `json:"details-level"`
	SanitizeHeaders utils.CommaSeparatedSlice `json:"sanitize-headers"`
	ExcludeHeaders  utils.CommaSeparatedSlice `json:"exclude-headers"`
}

type LoggingConfig struct {
	Level           log.LoggingLevel
	DetailsLevel    LogDetailsLevel
	SanitizeHeaders utils.StringSet
	ExcludeHeaders  utils.StringSet
}

type Request struct {
	Path       string
	Method     string
	Params     map[string]string
	Headers    http.Header
	Body       interface{}
	EncodeFunc httptransport.EncodeRequestFunc
}

type RequestOptions func(r *Request)

type Response struct {
	StatusCode int
	Headers    http.Header
	Body       interface{}
	RawBody    []byte `json:"-"`
}

type ResponseOptions func(opt *responseOption)

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