grpc

type Config struct {
	// Name is the entrypoint name.
	//
	// The default name is 'grpc-<random uuid>'
	Name string `json:"name" yaml:"name"`

	// Address to listen on.
	//
	// If no IP is provided, an interface will be selected automatically. Private
	// interfaces are preferred, if none are found a public interface will be used.
	//
	// If no port is provided, a random port will be selected. To listen on a
	// specific interface, but with a random port, you can use '<IP>:0'.
	Address string

	// Insecure will start the gRPC server without TLS.
	// If set to false, and no TLS certifiate is provided, a self-signed
	// certificate will be generated.
	//
	// WARNING: don't use this in production, unless you really know what you are
	// doing. this will result in unencrypted traffic. Really, it is even advised
	// against using this in testing environments.
	Insecure bool

	// TLS config, if none is provided a self-signed certificates will be generated.
	//
	// You can load a tls config from yaml/json with the following options:
	//
	// “`yaml
	// rootCAFiles:
	//    - xxx
	// clientCAFiles:
	//    - xxx
	// clientAuth: "none" | "request" | "require" |  "verify" | "require+verify"
	// certificates:
	//   - certFile: xxx
	//     keyFile: xxx
	// “`
	TLS *mtls.Config `json:"tls,omitempty" yaml:"tls,omitempty"`

	// HandlerRegistrations are all handler registration functions that will be
	// registered to the server upon startup.
	//
	// You can statically add handlers by using the fuctional server options.
	// Optionally, you can dynamically add handlers by registering them to the
	// Handlers global, and setting them explicitly in the config.
	HandlerRegistrations server.HandlerRegistrations `json:"handlers" yaml:"handlers"`

	// UnaryInterceptors are middlware for unary gRPC calls. These are all
	// request handlers that don't use streaming.
	//
	// Optionally selectors can be provided to the middleware to limit which
	// requests the middleware is called on.
	UnaryInterceptors matcher.Matcher[grpc.UnaryServerInterceptor] `json:"middleware" yaml:"middleware"`

	// StreamInterceptors are middlware for streaming gRPC calls.
	//
	// Optionally selectors can be provided to the middleware to limit which
	// requests the middleware is called on.
	StreamInterceptors matcher.Matcher[grpc.StreamServerInterceptor] `json:"streamMiddleware" yaml:"streamMiddleware"`

	// GRPCOptions are options provided by the grpc package, and will be directly
	// passed ot the gRPC server.
	GRPCOptions []grpc.ServerOption `json:"-" yaml:"-"`

	// HealthService dictates whether the gRPC health check protocol should be
	// implemented. This is an implementation provided by the grpc package.
	// Defaults to true.
	//
	// This is useful for healthprobes, such as in Kubernetes (>=1.24).
	HealthService bool `json:"health" yaml:"health"`

	// Reflection dictates whether the server should implementent gRPC
	// reflection. This is used by e.g. the gRPC proxy. Defaults to true.
	Reflection bool `json:"reflection" yaml:"reflection"`

	// Timeout adds a timeout to the request context on the request handler.
	//
	// The handler still needs to respect the context timeout for this to have
	// any effect.
	Timeout time.Duration `json:"timeout" yaml:"timeout"`

	// Listener is a custom listener. If none provided one will be created with
	// the address and TLS config.
	Listener net.Listener `json:"-" yaml:"-"`

	// Logger allows you to dynamically change the log level and plugin for a
	// specific entrypoint.
	Logger struct {
		Level  slog.Level `json:"level,omitempty" yaml:"level,omitempty"` // TODO(davincible): change with custom level
		Plugin string     `json:"plugin,omitempty" yaml:"plugin,omitempty"`
	} `json:"logger" yaml:"logger"`
}

type Option func(o *Config)

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