foundation

type CableCourier struct {
	*EventsWorker

	Options *CableCourierOptions
}

type CableCourierOptions struct {
	// Resolvers map protocol names to lists of CableMessageResolvers.
	Resolvers map[proto.Message][]CableMessageResolver
	// RedisChannel is the name of the Redis PubSub channel to publish events to.
	RedisChannel string
}

type CableCourierResolvers map[proto.Message][]CableMessageResolver

type CableGRPC struct {
	*Service

	Options *CableGRPCOptions
}

type CableGRPCOptions struct {
	// GRPCServerOptions are the gRPC server options to use.
	GRPCServerOptions []grpc.ServerOption

	// StartComponentsOptions are the options to start the components.
	StartComponentsOptions []StartComponentsOption

	// Channels are the channels to use.
	Channels map[string]cablegrpc.Channel

	// WithAuthentication enables authentication.
	WithAuthentication bool
	// AuthenticationFunc is the function to use for authentication.
	AuthenticationFunc cablegrpc.AuthenticationFunc
}

type CableMessageEventHandler struct {
	// Resolver is used to resolve the stream name for a given event.
	Resolver     CableMessageResolver
	Logger       *logrus.Entry
	Service      *Service
	RedisChannel string
}

type CableMessageResolver func(context.Context, *Event, proto.Message) (string, error)

type Component interface {
	// Health returns the health of the component
	Health() error
	// Name returns the name of the component
	Name() string
	// Start runs the component
	Start() error
	// Stop stops the component
	Stop() error
}

type Config struct {
	Database     *DatabaseConfig
	EventsWorker *EventsWorkerConfig
	GRPC         *GRPCConfig
	Kafka        *KafkaConfig
	Metrics      *MetricsConfig
	Outbox       *OutboxConfig
	Redis        *RedisConfig
	Sentry       *SentryConfig
	JobsEnqueuer *JobsEnqueuerConfig
}

type DatabaseConfig struct {
	Enabled bool
	Pool    int
	URL     string
}

type Env string

type ErrorHandlingStrategy int

type Event struct {
	Topic     string
	Key       string
	Payload   []byte
	ProtoName string
	Headers   map[string]string
	CreatedAt time.Time
}

type EventHandler interface {
	Handle(context.Context, *Event, proto.Message) ([]*Event, ferr.FoundationError)
}

type EventsWorker struct {
	*SpinWorker
	// contains filtered or unexported fields
}

type EventsWorkerConfig struct {
	// ErrorsTopic is the name of the Kafka topic to which errors from the
	// events worker handlers should be published.
	ErrorsTopic string

	// DeliverErrors determines whether errors from events worker handlers
	// should be published to the errors topic (and thus, delivered
	// to originator, aka user) or not.
	DeliverErrors bool
}

type EventsWorkerOptions struct {
	Handlers               map[proto.Message][]EventHandler
	Topics                 []string
	ModeName               string
	ErrorHandlingStrategy  ErrorHandlingStrategy
	StartComponentsOptions []StartComponentsOption
}

type GRPCConfig struct {
	TLSDir string
}

type GRPCServer struct {
	*Service

	Options *GRPCServerOptions
}

type GRPCServerOptions struct {
	// RegisterFunc is a function that registers the gRPC server implementation.
	RegisterFunc func(s *grpc.Server)

	// GRPCServerOptions are the gRPC server options to use.
	GRPCServerOptions []grpc.ServerOption

	// StartComponentsOptions are the options to start the components.
	StartComponentsOptions []StartComponentsOption
}

type Gateway struct {
	*Service

	Options *GatewayOptions
}

type GatewayOptions struct {
	// Services to register with the gateway
	Services []*gateway.Service
	// Timeout for downstream services requests (default: 30 seconds, if constructed with `NewGatewayOptions`)
	Timeout time.Duration
	// AuthenticationDetailsMiddleware is a middleware that populates the request context with authentication details.
	AuthenticationDetailsMiddleware func(http.Handler) http.Handler
	// WithAuthentication enables authentication for the gateway.
	WithAuthentication bool
	// AuthenticationExcept is a list of paths that should not be authenticated.
	AuthenticationExcept []string
	// Middleware is a list of middleware to apply to the gateway. The middleware is applied in the order it is defined.
	Middleware []func(http.Handler) http.Handler
	// StartComponentsOptions are the options to start the components.
	StartComponentsOptions []StartComponentsOption
	// CORSOptions are the options for CORS.
	CORSOptions *gateway.CORSOptions
}

type HTTPServer struct {
	*Service

	Options *HTTPServerOptions
}

type HTTPServerOptions struct {
	// Handler is the HTTP handler to use.
	Handler http.Handler

	// StartComponentsOptions are the options to start the components.
	StartComponentsOptions []StartComponentsOption
}

type JobOptions struct {
	Handler  func(job *work.Job) error
	Schedule string
	Options  *work.JobOptions
}

type JobsEnqueuerConfig struct {
	Enabled   bool
	URL       string
	Pool      int
	Namespace string
}

type JobsWorker struct {
	*Service

	Options *JobsWorkerOptions
}

type JobsWorkerOptions struct {
	// JobHandlers are the handlers to use for the jobs
	Jobs map[string]JobOptions
	// JobMiddlewares are the middlewares to use for all jobs
	Middlewares []func(job *work.Job, next work.NextMiddlewareFunc) error
	// Namespace is the redis namespace to use for the jobs
	Namespace string
	// Concurrency is the number of concurrent jobs to run
	Concurrency int
	// StartComponentsOptions are the options to start the components.
	StartComponentsOptions []StartComponentsOption
}

type KafkaConfig struct {
	Brokers  []string
	Consumer *KafkaConsumerConfig
	Producer *KafkaProducerConfig
	TLSDir   string
}

type KafkaConsumerConfig struct {
	Enabled bool
	Topics  []string
}

type KafkaProducerConfig struct {
	Enabled bool
}

type MetricsConfig struct {
	Enabled bool
	Port    int
}

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

type MetricsServerComponentOption func(*MetricsServerComponent)

type OutboxConfig struct {
	Enabled bool
}

type OutboxCourier struct {
	*SpinWorker
}

type OutboxCourierOptions struct {
	Interval               time.Duration
	BatchSize              int32
	ModeName               string
	StartComponentsOptions []StartComponentsOption
}

type RedisConfig struct {
	Enabled bool
	URL     string
}

type SentryConfig struct {
	DSN     string
	Enabled bool
}

type Service struct {
	Name       string
	Config     *Config
	Components []Component
	ModeName   string

	Logger *logrus.Entry
	// contains filtered or unexported fields
}

type SpinWorker struct {
	*Service

	Options *SpinWorkerOptions
}

type SpinWorkerOptions struct {
	// ProcessFunc is the function to execute in the loop iteration.
	ProcessFunc func(ctx context.Context) ferr.FoundationError

	// Interval is the interval to run the iteration function. If function execution took less time than the interval,
	// the worker will sleep for the remaining time of the interval. Otherwise, the function will be executed again
	// immediately. Default: 5ms, if constructed with NewSpinWorkerOptions().
	Interval time.Duration

	// ModeName is the name of the worker mode. It will be used in the startup log message. Default: "spin_worker".
	// Meant to be used in custom modes based on the `spin_worker` mode.
	ModeName string

	StartComponentsOptions []StartComponentsOption
}

type StartComponentsOption func(*Service)

type StartOptions struct {
	ModeName               string
	StartComponentsOptions []StartComponentsOption
	ServiceFunc            func(ctx context.Context) error
}