fx build fix

api/notification/internal/api/api.go

@@ -0,0 +1,146 @@
+package apiimp
+
+import (
+	"context"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/tech/sendico/notification/interface/api"
+	"github.com/tech/sendico/notification/interface/api/localizer"
+	"github.com/tech/sendico/notification/interface/services/amplitude"
+	"github.com/tech/sendico/notification/interface/services/notification"
+	"github.com/tech/sendico/pkg/db"
+	"github.com/tech/sendico/pkg/domainprovider"
+	"github.com/tech/sendico/pkg/messaging"
+	"github.com/tech/sendico/pkg/mlogger"
+	"github.com/tech/sendico/pkg/mservice"
+	"go.uber.org/zap"
+)
+
+type Microservices = []mservice.MicroService
+
+type APIImp struct {
+	logger    mlogger.Logger
+	db        db.Factory
+	localizer localizer.Localizer
+	domain    domainprovider.DomainProvider
+	config    *api.Config
+	services  Microservices
+	debug     bool
+	mw        *Middleware
+}
+
+func (a *APIImp) installMicroservice(srv mservice.MicroService) {
+	a.services = append(a.services, srv)
+	a.logger.Info("Microservice installed", zap.String("service", srv.Name()))
+}
+
+func (a *APIImp) addMicroservice(srvf api.MicroServiceFactoryT) error {
+	srv, err := srvf(a)
+	if err != nil {
+		a.logger.Error("Failed to install a microservice", zap.Error(err))
+		return err
+	}
+
+	a.installMicroservice(srv)
+	return nil
+}
+
+func (a *APIImp) Logger() mlogger.Logger {
+	return a.logger
+}
+
+func (a *APIImp) Config() *api.Config {
+	return a.config
+}
+
+func (a *APIImp) Localizer() localizer.Localizer {
+	return a.localizer
+}
+
+func (a *APIImp) DBFactory() db.Factory {
+	return a.db
+}
+
+func (a *APIImp) DomainProvider() domainprovider.DomainProvider {
+	return a.domain
+}
+
+func (a *APIImp) Register() messaging.Register {
+	return a.mw
+}
+
+func (a *APIImp) installServices() error {
+	srvf := make([]api.MicroServiceFactoryT, 0)
+
+	srvf = append(srvf, amplitude.Create)
+	srvf = append(srvf, notification.Create)
+
+	for _, v := range srvf {
+		err := a.addMicroservice(v)
+		if err != nil {
+			return err
+		}
+	}
+
+	a.mw.SetStatus("ok")
+	return nil
+}
+
+func (a *APIImp) Finish(ctx context.Context) error {
+	a.mw.SetStatus("deactivating")
+	a.mw.Finish()
+	var lastError error
+	// stop services in the reverse order
+	for i := len(a.services) - 1; i >= 0; i-- {
+		err := (a.services[i]).Finish(ctx)
+		if err != nil {
+			lastError = err
+			a.logger.Warn("Error occurred when finishing service",
+				zap.Error(err),
+				zap.String("service_name", (a.services[i]).Name()))
+		} else {
+			a.logger.Info("Microservice is down",
+				zap.String("service_name", (a.services[i]).Name()))
+		}
+	}
+	return lastError
+}
+
+func (a *APIImp) Name() string {
+	return "api"
+}
+
+func CreateAPI(logger mlogger.Logger, config *api.Config, l localizer.Localizer, db db.Factory, router *chi.Mux, debug bool) (mservice.MicroService, error) {
+	p := new(APIImp)
+	p.logger = logger.Named("api")
+	p.debug = debug
+	p.config = config
+	p.db = db
+	p.localizer = l
+
+	var err error
+	if p.domain, err = domainprovider.CreateDomainProvider(p.logger, config.Mw.DomainEnv, config.Mw.APIProtocolEnv, config.Mw.EndPointEnv); err != nil {
+		p.logger.Error("Failed to initizlize domain provider")
+		return nil, err
+	}
+	odb, err := db.NewOrganizationDB()
+	if err != nil {
+		p.logger.Warn("Failed to create organization database", zap.Error(err))
+		return nil, err
+	}
+
+	if p.mw, err = CreateMiddleware(logger, odb, router, config.Mw, debug); err != nil {
+		p.logger.Warn("Failed to create middleware", zap.Error(err))
+		return nil, err
+	}
+
+	p.logger.Info("Installing microservices...")
+	if err := p.installServices(); err != nil {
+		p.logger.Error("Failed to install a microservice", zap.Error(err))
+		return nil, err
+	}
+
+	p.logger.Info("Microservices installation complete", zap.Int("microservices", len(p.services)))
+
+	return p, nil
+}

api/notification/internal/api/config/config.go

@@ -0,0 +1,42 @@
+package apiimp
+
+import "github.com/tech/sendico/pkg/messaging"
+
+type CORSSettings struct {
+	MaxAge           int      `yaml:"max_age"`
+	AllowedOrigins   []string `yaml:"allowed_origins"`
+	AllowedMethods   []string `yaml:"allowed_methods"`
+	AllowedHeaders   []string `yaml:"allowed_headers"`
+	ExposedHeaders   []string `yaml:"exposed_headers"`
+	AllowCredentials bool     `yaml:"allow_credentials"`
+}
+
+type SignatureConf struct {
+	PublicKey  any
+	PrivateKey []byte
+	Algorithm  string
+}
+
+type Signature struct {
+	PublicKeyEnv  string `yaml:"public_key_env,omitempty"`
+	PrivateKeyEnv string `yaml:"secret_key_env"`
+	Algorithm     string `yaml:"algorithm"`
+}
+
+type WebSocketConfig struct {
+	EndpointEnv string `yaml:"endpoint_env"`
+	Timeout     int    `yaml:"timeout"`
+}
+
+type MessagingConfig struct {
+	BufferSize int `yaml:"buffer_size"`
+}
+
+type Config struct {
+	DomainEnv      string           `yaml:"domain_env"`
+	EndPointEnv    string           `yaml:"api_endpoint_env"`
+	APIProtocolEnv string           `yaml:"api_protocol_env"`
+	Messaging      messaging.Config `yaml:"message_broker"`
+}
+
+type MapClaims = map[string]any

api/notification/internal/api/middleware.go

@@ -0,0 +1,59 @@
+package apiimp
+
+import (
+	"os"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/tech/sendico/notification/interface/middleware"
+	"github.com/tech/sendico/pkg/api/routers"
+	"github.com/tech/sendico/pkg/api/routers/health"
+	"github.com/tech/sendico/pkg/db/organization"
+	"github.com/tech/sendico/pkg/messaging"
+	notifications "github.com/tech/sendico/pkg/messaging/notifications/processor"
+	"github.com/tech/sendico/pkg/mlogger"
+	"go.uber.org/zap"
+)
+
+type Middleware struct {
+	logger      mlogger.Logger
+	router      *chi.Mux
+	apiEndpoint string
+	health      routers.Health
+	messaging   routers.Messaging
+}
+
+func (mw *Middleware) Consumer(processor notifications.EnvelopeProcessor) error {
+	return mw.messaging.Consumer(processor)
+}
+
+func (mw *Middleware) Producer() messaging.Producer {
+	return mw.messaging.Producer()
+}
+
+func (mw *Middleware) Finish() {
+	mw.messaging.Finish()
+	mw.health.Finish()
+}
+
+func (mw *Middleware) SetStatus(status health.ServiceStatus) {
+	mw.health.SetStatus(status)
+}
+
+func CreateMiddleware(logger mlogger.Logger, db organization.DB, router *chi.Mux, config *middleware.Config, debug bool) (*Middleware, error) {
+	p := &Middleware{
+		logger:      logger.Named("middleware"),
+		router:      router,
+		apiEndpoint: os.Getenv(config.EndPointEnv),
+	}
+	p.logger.Info("Set endpoint", zap.String("endpoint", p.apiEndpoint))
+	var err error
+	if p.messaging, err = routers.NewMessagingRouter(logger, &config.Messaging); err != nil {
+		p.logger.Error("Failed to create messaging router", zap.Error(err))
+		return nil, err
+	}
+	if p.health, err = routers.NewHealthRouter(p.logger, p.router, p.apiEndpoint); err != nil {
+		p.logger.Error("Failed to create healthcheck router", zap.Error(err), zap.String("api_endpoint", p.apiEndpoint))
+		return nil, err
+	}
+	return p, nil
+}