serviceregistry

type DBRegister struct {
	// Required is a flag that indicates whether the service requires a database connection.
	Required bool
	// Migrations is an embedded filesystem that contains the Goose SQL migrations for the service.
	// This is required to support the `migrate` command or the `runMigrations` configuration option.
	// More information on Goose can be found at https://github.com/pressly/goose
	Migrations *embed.FS
}

type HandlerServer func(ctx context.Context, mux *runtime.ServeMux) error

type IService interface {
	IsDBRequired() bool
	DBMigrations() *embed.FS
	GetNamespace() string
	GetVersion() string
	GetServiceDesc() *grpc.ServiceDesc
	Start(ctx context.Context, params RegistrationParams) error
	IsStarted() bool
	Shutdown() error
	RegisterConfigUpdateHook(ctx context.Context, hookAppender func(config.ChangeHook)) error
	RegisterConnectRPCServiceHandler(context.Context, *server.ConnectRPC) error
	RegisterGRPCGatewayHandler(context.Context, *runtime.ServeMux, *grpc.ClientConn) error
	RegisterHTTPHandlers(context.Context, *runtime.ServeMux) error
}

type ModeName string

type Namespace struct {
	Mode     string
	Version  string
	Services []IService
}

type NamespaceInfo struct {
	Name      string
	Namespace *Namespace
}

type OnConfigUpdateHook func(context.Context, config.ServiceConfig) error

type RegisterFunc[S any] func(RegistrationParams) (impl S, HandlerServer HandlerServer)

type RegistrationParams struct {
	// Config scoped to the service config. Since the main config contains all the service configs,
	// which could have need-to-know information we don't want to expose it to all services.
	Config config.ServiceConfig
	// Security exposes platform-wide security overrides.
	Security *config.SecurityConfig
	// OTDF is the OpenTDF server that can be used to interact with the OpenTDFServer instance.
	OTDF *server.OpenTDFServer
	// DBClient is the database client that can be used to interact with the database. This client
	// is scoped to the service namespace and will not be shared with other service namespaces.
	DBClient *db.Client
	// SDK is the OpenTDF SDK that can be used to interact with the OpenTDF SDK. This is useful for
	// gRPC Inter Process Communication (IPC) between services. This ensures the services are
	// communicating with each other by contract as well as supporting the various deployment models
	// that OpenTDF supports.
	SDK *sdk.SDK
	// Logger is the logger that can be used to log messages. This logger is scoped to the service
	Logger *logger.Logger
	trace.Tracer

	// NewCacheClient is a function that can be used to create a new cache instance for the service
	NewCacheClient func(cache.Options) (*cache.Cache, error)

	// KeyManagerFactories are the registered key manager factories that can be used to create
	// key managers for the service to use.
	// Prefer KeyManagerCtxFactories
	// EXPERIMENTAL
	KeyManagerFactories []trust.NamedKeyManagerFactory

	// KeyManagerCtxFactories are the registered key manager context factories that can be used to create
	// key managers for the service to use.
	// EXPERIMENTAL
	KeyManagerCtxFactories []trust.NamedKeyManagerCtxFactory

	// RegisterWellKnownConfig is a function that can be used to register a well-known configuration
	WellKnownConfig func(namespace string, config any) error
	// RegisterReadinessCheck is a function that can be used to register a readiness check for the
	// service. This is useful for services that need to perform some initialization before they are
	// ready to serve requests. This function should be called in the RegisterFunc function.
	RegisterReadinessCheck func(namespace string, check func(context.Context) error) error
}

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

type Service[S any] struct {

	// Started is a flag that indicates whether the service has been started
	Started bool
	// Close is a function that can be called to close the service
	Close func()
	// Service Options
	ServiceOptions[S]
	// contains filtered or unexported fields
}

type ServiceConfigError struct {
	Type    string
	Mode    string
	Service string
	Message string
}

type ServiceConfiguration struct {
	Name     ServiceName
	Modes    []ModeName
	Services []IService
}

type ServiceName interface {
	String() string
}

type ServiceOptions[S any] struct {
	// Namespace is the namespace of the service. One or more gRPC services can be registered under
	// the same namespace.
	Namespace string
	// Version is the major version of the service according to the protocol buffer definition.
	Version string
	// ServiceDesc is the gRPC service descriptor. For non-gRPC services, this can be mocked out,
	// but at minimum, the ServiceName field must be set
	ServiceDesc *grpc.ServiceDesc
	// OnConfigUpdate is a hook to handle in-service actions when config changes
	OnConfigUpdate OnConfigUpdateHook
	// RegisterFunc is the function that will be called to register the service
	RegisterFunc RegisterFunc[S]

	// ConnectRPCServiceHandler is the function that will be called to register the service with the
	ConnectRPCFunc func(S, ...connect.HandlerOption) (string, http.Handler)
	// Deprecated: Registers a gRPC service with the gRPC gateway
	GRPCGatewayFunc func(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error
	// DB is optional and used to register the service with a database
	DB DBRegister
	// contains filtered or unexported fields
}