client

type BackoffFunc func(ctx context.Context, req Request[any, any], attempts int) (time.Duration, error)

type CallOption func(*CallOptions)

type CallOptions struct {
	// Used to select a codec
	ContentType string

	// PreferredTransports contains a list of transport names in preferred order.
	PreferredTransports []string

	// PoolHosts sets the number of hosts in a pool
	PoolHosts int
	// PoolSize sets the connection pool size per service.
	PoolSize int
	// PoolTTL sets the connection pool ttl.
	PoolTTL time.Duration

	AnyTransport bool

	// Selector is the node selector.
	Selector SelectorFunc
	// Backoff func
	Backoff BackoffFunc
	// Check if retriable func
	Retry RetryFunc
	// Number of Call attempts
	Retries int
	// Transport Dial Timeout. Used for initial dial to establish a connection.
	DialTimeout time.Duration
	// ConnectionTimeout of one request to the server.
	// Set this lower than the RequestTimeout to enable retries on connection timeout.
	ConnectionTimeout time.Duration
	// Request/Response timeout of entire srv.Call, for single request timeout set ConnectionTimeout.
	RequestTimeout time.Duration
	// Stream timeout for the stream
	StreamTimeout time.Duration
	// ConnClose sets the Connection: close header.
	ConnClose bool
	// URL bypasses the registry when set. This is mainly for tests.
	// Only <scheme>://<host:port> will be used from it.
	URL string
	// TLS config.
	TLSConfig *tls.Config
	// ResponseMetadata will be written into `ResponseMetadata` when given.
	ResponseMetadata map[string]string
}

type Client interface {
	types.Component

	// Config returns the internal config, this is for tests.
	Config() Config

	// With closes all transports and configures the client with the given options.
	With(opts ...Option) error

	ResolveService(ctx context.Context, service string, preferredTransports ...string) (NodeMap, error)

	// NeedsCodec has to do node resolving and then selects the right transport for that node,
	// it then has to return whatever the selected transport needs a codec or if it does encoding internaly.
	NeedsCodec(ctx context.Context, req *Request[any, any], opts ...CallOption) bool

	// Call with encoding on client side.
	Call(ctx context.Context, req *Request[any, any], result any, opts ...CallOption) (*RawResponse, error)

	// CallNoCodec is the same as Call but without encoding.
	CallNoCodec(ctx context.Context, req *Request[any, any], result any, opts ...CallOption) error
}

type Config struct {
	// Plugin selects the client implementation.
	Plugin string `json:"plugin" yaml:"plugin"`

	Middleware []MiddlewareConfig

	// Used to select a codec
	ContentType string `json:"contentType" yaml:"contentType"`

	// PreferredTransports contains a list of transport names in preferred order.
	PreferredTransports []string `json:"preferredTransports" yaml:"preferredTransports"`

	// AnyTransport enables Transports which are not in PreferredTransports.
	AnyTransport bool `json:"anyTransport" yaml:"anyTransport"`

	// Connection Pool
	PoolHosts int           `json:"poolHosts" yaml:"poolHosts"`
	PoolSize  int           `json:"poolSize"  yaml:"poolSize"`
	PoolTTL   time.Duration `json:"poolTtl"   yaml:"poolTtl"`

	// SelectorFunc get's executed by client.SelectNode which get it's info's from client.ResolveService.
	Selector SelectorFunc `json:"-" yaml:"-"`

	// Backoff func
	Backoff BackoffFunc `json:"-" yaml:"-"`
	// Check if retriable func
	Retry RetryFunc `json:"-" yaml:"-"`
	// Number of Call attempts
	Retries int `json:"retries" yaml:"retries"`
	// Transport Dial Timeout. Used for initial dial to establish a connection.
	DialTimeout time.Duration `json:"dialTimeout" yaml:"dialTimeout"`
	// ConnectionTimeout of one request to the server.
	// Set this lower than the RequestTimeout to enbale retries on connection timeout.
	ConnectionTimeout time.Duration `json:"connectionTimeout" yaml:"connectionTimeout"`
	// Request/Response timeout of entire srv.Call, for single request timeout set ConnectionTimeout.
	RequestTimeout time.Duration `json:"requestTimeout" yaml:"requestTimeout"`
	// Stream timeout for the stream
	StreamTimeout time.Duration `json:"streamTimeout" yaml:"streamTimeout"`
	// TLS config.
	TLSConfig *tls.Config
}

type ConfigType interface {
	// contains filtered or unexported methods
}

type Middleware interface {
	types.Component

	Call(
		next MiddlewareCallHandler,
	) MiddlewareCallHandler

	CallNoCodec(
		next MiddlewareCallNoCodecHandler,
	) MiddlewareCallNoCodecHandler
}

type MiddlewareCallHandler func(ctx context.Context, req *Request[any, any], opts *CallOptions) (*RawResponse, error)

type MiddlewareCallNoCodecHandler func(ctx context.Context, req *Request[any, any], result any, opts *CallOptions) error

type MiddlewareConfig struct {
	Name string `json:"name" yaml:"name"`
}

type MiddlewareFactory func(configSection []string, configs types.ConfigData, client Type, logger log.Logger) (Middleware, error)

type NodeMap map[string][]*registry.Node

type Option func(ConfigType)

type ProviderFunc func(
	name types.ServiceName,
	data types.ConfigData,
	logger log.Logger,
	registry registry.Type,
	opts ...Option,
) (Type, error)

type RawResponse = Response[io.Reader]

type Request[TResp any, TReq any] struct {
	// contains filtered or unexported fields
}

type Response[T any] struct {
	ContentType string
	Body        T
}

type RetryFunc func(ctx context.Context, req Request[any, any], retryCount int, err error) (bool, error)

type SelectorFunc func(
	ctx context.Context,
	service string,
	nodes NodeMap,
	preferredTransports []string,
	anyTransport bool,
) (*registry.Node, error)

type Type struct {
	Client
}