04-03. Add fetching course command

Author: etrapani

.idea/.gitignore

@@ -3,6 +3,7 @@ package bootstrap
 import (
 	"database/sql"
 	"fmt"
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/fetching"
 
 	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/creating"
 	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/platform/bus/inmemory"
@@ -30,16 +31,20 @@ func Run() error {
 	}
 
 	var (
-		commandBus = inmemory.NewCommandBus()
+		bus = inmemory.NewCommandBus()
 	)
 
 	courseRepository := mysql.NewCourseRepository(db)
 
 	creatingCourseService := creating.NewCourseService(courseRepository)
+	fetchingCourseService := fetching.NewCourseFetchingService(courseRepository)
 
 	createCourseCommandHandler := creating.NewCourseCommandHandler(creatingCourseService)
-	commandBus.Register(creating.CourseCommandType, createCourseCommandHandler)
+	fetchingCourseQueryHandler := fetching.NewCourseQueryHandler(fetchingCourseService)
 
-	srv := server.New(host, port, commandBus)
+	bus.RegisterCommandHandler(creating.CourseCommandType, createCourseCommandHandler)
+	bus.RegisterQueryHandler(fetching.CourseQueryType, fetchingCourseQueryHandler)
+
+	srv := server.New(host, port, bus)
 	return srv.Run()
 }

.idea/go-hexagonal_http_api-course.iml

@@ -87,6 +87,7 @@ type Course struct {
 // CourseRepository defines the expected behaviour from a course storage.
 type CourseRepository interface {
 	Save(ctx context.Context, course Course) error
+	GetAll(ctx context.Context) ([]Course, error)
 }
 
 //go:generate mockery --case=snake --outpkg=storagemocks --output=platform/storage/storagemocks --name=CourseRepository

.idea/modules.xml

@@ -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/vcs.xml

@@ -27,3 +27,4 @@ func (s CourseService) CreateCourse(ctx context.Context, id, name, duration stri
 	}
 	return s.courseRepository.Save(ctx, course)
 }
+

04-03-command-bus/cmd/api/bootstrap/boostrap.go

@@ -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)
+}

04-03-command-bus/internal/course.go

@@ -0,0 +1,25 @@
+package fetching
+
+import (
+	"context"
+
+	mooc "github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal"
+)
+
+// CourseService is the default CourseService interface
+// implementation returned by fetching.NewCourseFetchingService.
+type FetchingCourseService struct {
+	courseRepository mooc.CourseRepository
+}
+
+// NewCourseService returns the default Service interface implementation.
+func NewCourseFetchingService(courseRepository mooc.CourseRepository) FetchingCourseService {
+	return FetchingCourseService{
+		courseRepository: courseRepository,
+	}
+}
+
+// CreateCourse implements the creating.CourseService interface.
+func (s FetchingCourseService) GetAll(ctx context.Context) ([]mooc.Course, error) {
+	return s.courseRepository.GetAll(ctx)
+}