services

type Database interface {
	Generic
	WithServiceManager(c ServiceManager) Database
	WithUserDatabase() Database
	WithMasterClient(*sql.DB) Database
	WithReplicaClient(*sql.DB) Database
	OpenTransactionMaster(ctx context.Context) (context.Context, error)
	TransactionMaster(ctx context.Context, f func(tx DatabaseTransaction) error) error
	OpenTransactionReplica(ctx context.Context) (context.Context, error)
	TransactionReplica(ctx context.Context, f func(tx DatabaseTransaction) error) error
	CloseTransaction(ctx context.Context, err error) error
}

type DatabaseTransaction interface {
	Insert(query string, args ...interface{}) (sql.Result, error)
	Update(query string, args ...interface{}) (sql.Result, error)
	Get(query string, args ...interface{}) (*sql.Rows, error)
	Migrate(script string) (sql.Result, error)
}

type Environment interface {
	Generic
	WithServiceManager(c ServiceManager) Environment
	Env() string
	Service() string
	Version() string
	DebugPprof() bool
	AwsRegion() string
	AwsEndpoint() string
	AwsAccessKey() string
	AwsSecretKey() string
	SpanUrl() string
	UserDatabaseDsn() string
	UserReplicaDatabaseDsn() string
	UserTopicAddress() string
	Configs() map[string]interface{}
}

type Events interface {
	Generic
	WithServiceManager(c ServiceManager) Events
	Send(ctx context.Context, req domains.EventRequest) error
	SendBulk(ctx context.Context, req []domains.EventRequest) error
}

type Generic interface {
	ServiceManager() ServiceManager
	Init(ctx context.Context) error
	Close() error
	Readiness(ctx context.Context) error
	Liveness(ctx context.Context) error
}

type HttpServer interface {
	Generic
	WithServiceManager(c ServiceManager) HttpServer
	Run() error
}

type Logger interface {
	Generic
	WithServiceManager(c ServiceManager) Logger
	WithCallerCount(c int) Logger
	Info(ctx context.Context, message string, fields ...map[string]interface{})
	Warn(ctx context.Context, message string, fields ...map[string]interface{})
	Error(ctx context.Context, message string, fields ...map[string]interface{})
	Fatal(ctx context.Context, message string, fields ...map[string]interface{})
}

type NoopDatabase struct {
	NoopHealth
	NoopServiceManager
}

type NoopEnvironment struct {
	NoopHealth
	NoopServiceManager
}

type NoopEvents struct {
	NoopHealth
	NoopServiceManager
}

type NoopHealth struct{}

type NoopHttpServer struct {
	NoopHealth
	NoopServiceManager
}

type NoopLogger struct {
	NoopHealth
	NoopServiceManager
}

type NoopServiceManager struct{}

type NoopSpans struct {
	NoopHealth
	NoopServiceManager
}

type NoopUsersHandler struct {
	NoopHealth
	NoopServiceManager
}

type NoopUsersRepository struct {
	NoopHealth
	NoopServiceManager
}

type NoopValidator struct {
	NoopHealth
	NoopServiceManager
}

type ServiceManager interface {
	Init() error
	Close() error
	Readiness(ctx context.Context) error
	Liveness(ctx context.Context) error
	Context() context.Context
	WithLogger(d Logger) ServiceManager
	Logger() Logger
	WithHttpServer(d HttpServer) ServiceManager
	HttpServer() HttpServer
	WithEnvironment(d Environment) ServiceManager
	Environment() Environment
	WithValidator(d Validator) ServiceManager
	Validator() Validator
	WithSpans(d Spans) ServiceManager
	Spans() Spans
	WithUserDatabase(d Database) ServiceManager
	UserDatabase() Database
	WithUsersRepository(d UsersRepository) ServiceManager
	UsersRepository() UsersRepository
	WithUsersHandler(d UsersHandler) ServiceManager
	UsersHandler() UsersHandler
	WithUsersEvents(d Events) ServiceManager
	UsersEvents() Events
}

type Spans interface {
	Generic
	WithServiceManager(c ServiceManager) Spans
	New(ctx context.Context, spanConfigs ...domains.SpanConfig) (context.Context, *domains.Span)
	Tracer() *zipkin.Tracer
}

type UsersHandler interface {
	Generic
	WithServiceManager(c ServiceManager) UsersHandler
	Create(ctx context.Context, c domains.UserCreate) (*domains.User, error)
	Update(ctx context.Context, c domains.UserUpdate) (*domains.User, error)
	Get(ctx context.Context, productId string) (*domains.User, error)
	List(ctx context.Context) ([]domains.User, error)
	Delete(ctx context.Context, productId string) (*domains.User, error)
}

type UsersRepository interface {
	Generic
	WithServiceManager(ServiceManager) UsersRepository
	Search(ctx context.Context, search domains.UserSearch) ([]domains.User, error)
	Create(ctx context.Context, product *domains.User) error
	Update(ctx context.Context, product *domains.User) error
	Delete(ctx context.Context, product *domains.User) error
	Migrate(ctx context.Context) error
}

type Validator interface {
	Generic
	WithServiceManager(c ServiceManager) Validator
	Validate(ctx context.Context, obj interface{}) error
	ValidateSlice(ctx context.Context, objs interface{}) error
}