Agregado de event, command y query handlers

Author: etrapani

.idea/.gitignore

@@ -31,7 +31,7 @@ func Run() error {
 	}
 
 	var (
-		commandBus = inmemory.NewCommandBus()
+		bus = inmemory.NewCommandBus()
 	)
 
 	courseRepository := mysql.NewCourseRepository(db)
@@ -40,11 +40,11 @@ func Run() error {
 	fetchingCourseService := fetching.NewCourseFetchingService(courseRepository)
 
 	createCourseCommandHandler := creating.NewCourseCommandHandler(creatingCourseService)
-	fetchingCourseCommandHandler := fetching.NewCourseCommandHandler(fetchingCourseService)
+	fetchingCourseQueryHandler := fetching.NewCourseQueryHandler(fetchingCourseService)
 
-	commandBus.Register(creating.CourseCommandType, createCourseCommandHandler)
-	commandBus.Register(fetching.CourseCommandType, fetchingCourseCommandHandler)
+	bus.RegisterCommandHandler(creating.CourseCommandType, createCourseCommandHandler)
+	bus.RegisterQueryHandler(fetching.CourseQueryType, fetchingCourseQueryHandler)
 
-	srv := server.New(host, port, commandBus)
+	srv := server.New(host, port, bus)
 	return srv.Run()
 }

.idea/go-hexagonal_http_api-course.iml

@@ -4,12 +4,12 @@ import (
 	"context"
 	"errors"
 
-	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/command"
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/bus"
 )
 
-const CourseCommandType command.Type = "command.creating.course"
+const CourseCommandType bus.Type = "bus.creating.course"
 
-// CourseCommand is the command dispatched to create a new course.
+// CourseCommand is the bus dispatched to create a new course.
 type CourseCommand struct {
 	id       string
 	name     string
@@ -25,11 +25,11 @@ func NewCourseCommand(id, name, duration string) CourseCommand {
 	}
 }
 
-func (c CourseCommand) Type() command.Type {
+func (c CourseCommand) Type() bus.Type {
 	return CourseCommandType
 }
 
-// CourseCommandHandler is the command handler
+// CourseCommandHandler is the bus handler
 // responsible for creating courses.
 type CourseCommandHandler struct {
 	service CourseService
@@ -42,11 +42,11 @@ func NewCourseCommandHandler(service CourseService) CourseCommandHandler {
 	}
 }
 
-// Handle implements the command.Handler interface.
-func (h CourseCommandHandler) Handle(ctx context.Context, cmd command.Command) error {
+// Handle implements the bus.CommandHandler interface.
+func (h CourseCommandHandler) Handle(ctx context.Context, cmd bus.Command) error {
 	createCourseCmd, ok := cmd.(CourseCommand)
 	if !ok {
-		return errors.New("unexpected command")
+		return errors.New("unexpected bus")
 	}
 
 	return h.service.CreateCourse(

.idea/modules.xml

@@ -0,0 +1,45 @@
+package fetching
+
+import (
+	"context"
+	"errors"
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/bus"
+)
+
+const CourseQueryType bus.Type = "bus.fetching.courses"
+
+// CourseQuery is the bus dispatched to create a new course.
+type CourseQuery struct {
+}
+
+// NewFetchCourseQuery creates a new CourseQuery.
+func NewFetchCourseQuery() CourseQuery {
+	return CourseQuery{}
+}
+
+func (c CourseQuery) Type() bus.Type {
+	return CourseQueryType
+}
+
+// CourseQueryHandler is the bus handler
+// responsible for fetching courses.
+type CourseQueryHandler struct {
+	service FetchingCourseService
+}
+
+// NewCourseQueryHandler initializes a new NewCourseQueryHandler.
+func NewCourseQueryHandler(service FetchingCourseService) CourseQueryHandler {
+	return CourseQueryHandler{
+		service: service,
+	}
+}
+
+// Handle implements the bus.QueryHandler interface.
+func (h CourseQueryHandler) Handle(ctx context.Context, query bus.Query) (bus.QueryResponse, error) {
+	_, ok := query.(CourseQuery)
+	if !ok {
+		return nil, errors.New("unexpected bus")
+	}
+
+	return h.service.GetAll(ctx)
+}

.idea/vcs.xml

@@ -0,0 +1,85 @@
+package inmemory
+
+import (
+	"context"
+	"log"
+
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/bus"
+)
+
+// Bus is an in-memory implementation of the bus.Bus.
+type Bus struct {
+	commandsHandlers map[bus.Type]bus.CommandHandler
+	queryHandlers map[bus.Type]bus.QueryHandler
+	eventHandlers map[bus.Type]bus.EventHandler
+}
+
+// NewCommandBus initializes a new instance of Bus.
+func NewCommandBus() *Bus {
+	return &Bus{
+		commandsHandlers: make(map[bus.Type]bus.CommandHandler),
+		queryHandlers: make(map[bus.Type]bus.QueryHandler),
+		eventHandlers: make(map[bus.Type]bus.EventHandler),
+	}
+}
+
+// DispatchCommand implements the bus.Bus interface.
+func (b *Bus) DispatchCommand(ctx context.Context, cmd bus.Command) error {
+	handler, ok := b.commandsHandlers[cmd.Type()]
+	if !ok {
+		return nil
+	}
+
+	go func() {
+		err := handler.Handle(ctx, cmd)
+		if err != nil {
+			log.Printf("Error while handling %s - %s\n", cmd.Type(), err)
+		}
+
+	}()
+
+	return nil
+}
+
+// RegisterCommandHandler implements the bus.Bus interface.
+func (b *Bus) RegisterCommandHandler(cmdType bus.Type, handler bus.CommandHandler) {
+	b.commandsHandlers[cmdType] = handler
+}
+
+// DispatchQuery implements the bus.Bus interface.
+func (b *Bus) DispatchQuery(ctx context.Context, query bus.Query) (bus.QueryResponse, error) {
+	handler, ok := b.queryHandlers[query.Type()]
+	if !ok {
+		return nil, nil
+	}
+	// Como este es sincronico, decide el que lo usa si lo espera o no.
+	return handler.Handle(ctx, query)
+}
+
+// RegisterQueryHandler implements the bus.Bus interface.
+func (b *Bus) RegisterQueryHandler(queryType bus.Type, handler bus.QueryHandler) {
+	b.queryHandlers[queryType] = handler
+}
+
+// DispatchEvent implements the bus.Bus interface.
+func (b *Bus) DispatchEvent(ctx context.Context, event bus.Event) error {
+	handler, ok := b.eventHandlers[event.Type()]
+	if !ok {
+		return nil
+	}
+
+	go func() {
+		err := handler.Handle(ctx, event)
+		if err != nil {
+			log.Printf("Error while handling %s - %s\n", event.Type(), err)
+		}
+
+	}()
+
+	return nil
+}
+
+// RegisterEventHandler implements the bus.Bus interface.
+func (b *Bus) RegisterEventHandler(cmdType bus.Type, handler bus.EventHandler) {
+	b.eventHandlers[cmdType] = handler
+}