Implement Dummy API for Project Understanding

backend-go/api/codepair/v1/models/errors.go

@@ -0,0 +1,11 @@
+package models
+
+import "errors"
+
+func RequiredFieldError(field string) error {
+	return errors.New(field + " is required")
+}
+
+func MinLengthError(field string, min int) error {
+	return errors.New(field + " must be at least " + string(min) + " characters")
+}

backend-go/api/codepair/v1/models/model_hello_request.go

@@ -0,0 +1,7 @@
+package models
+
+type HelloRequest struct {
+
+	// New nickname to say hello
+	Nickname string `json:"nickname"`
+}

backend-go/api/codepair/v1/models/model_hello_response.go

@@ -0,0 +1,7 @@
+package models
+
+type HelloResponse struct {
+
+	// Welcome message
+	Message string `json:"message"`
+}

backend-go/api/codepair/v1/models/model_http_exception_response.go

@@ -3,7 +3,7 @@ package models
 type HttpExceptionResponse struct {
 
 	// HTTP status code
-	StatusCode float32 `json:"statusCode"`
+	StatusCode int32 `json:"statusCode"`
 
 	// Description of the error
 	Message string `json:"message"`

backend-go/api/codepair/v1/models/validators.go

@@ -0,0 +1,13 @@
+package models
+
+func (r *HelloRequest) Validate() error {
+	if r.Nickname == "" {
+		return RequiredFieldError("nickname")
+	}
+
+	if len(r.Nickname) < 2 {
+		return MinLengthError("nickname", 2)
+	}
+
+	return nil
+}

backend-go/internal/core/hello/handler.go

@@ -0,0 +1,39 @@
+package hello
+
+import (
+	"github.com/labstack/echo/v4"
+	"github.com/yorkie-team/codepair/backend/api/codepair/v1/models"
+	"github.com/yorkie-team/codepair/backend/internal/transport/rest"
+)
+
+type Handler struct {
+	helloService Service
+}
+
+// NewHandler creates a new handler for hello.
+func NewHandler(service Service) Handler {
+	return Handler{
+		helloService: service,
+	}
+}
+
+// HelloCodePair returns a hello message for a given CodePairVisitor.
+func (h Handler) HelloCodePair(e echo.Context) error {
+	data := new(models.HelloRequest)
+
+	if err := rest.BindAndValidateRequest(e, data); err != nil {
+		return err
+	}
+
+	helloMessage, err := h.helloService.HelloCodePair(e, CodePairVisitor{
+		Nickname: data.Nickname,
+	})
+
+	if err != nil {
+		return rest.NewErrorResponse(e, err)
+	}
+
+	return rest.NewOkResponse(e, models.HelloResponse{
+		Message: helloMessage,
+	})
+}

backend-go/internal/core/hello/model.go

@@ -0,0 +1,7 @@
+package hello
+
+// CodePairVisitor is a visitor for CodePair
+type CodePairVisitor struct {
+	// Nickname is the nickname of the visitor
+	Nickname string
+}

backend-go/internal/core/hello/repository.go

@@ -0,0 +1,6 @@
+package hello
+
+type Repository interface {
+	// ReadHelloMessageFor reads a hello message for a given CodePairVisitor
+	ReadHelloMessageFor(codePairVisitor CodePairVisitor) (string, error)
+}

backend-go/internal/core/hello/service.go

@@ -0,0 +1,27 @@
+package hello
+
+import (
+	"github.com/labstack/echo/v4"
+	"github.com/yorkie-team/codepair/backend/internal/transport/rest"
+)
+
+type Service struct {
+	helloRepository Repository
+}
+
+// NewService creates a new service for hello.
+func NewService(repository Repository) Service {
+	return Service{
+		helloRepository: repository,
+	}
+}
+
+// HelloCodePair returns a hello message for a given CodePairVisitor
+func (s Service) HelloCodePair(e echo.Context, codePairVisitor CodePairVisitor) (string, error) {
+	helloMessage, err := s.helloRepository.ReadHelloMessageFor(codePairVisitor)
+	if err != nil {
+		e.Logger().Fatal(err)
+		return "", rest.InternalServerError
+	}
+	return helloMessage, nil
+}

backend-go/internal/infra/database/mongo/hello.go

@@ -0,0 +1,14 @@
+package mongo
+
+import "github.com/yorkie-team/codepair/backend/internal/core/hello"
+
+type HelloRepository struct{}
+
+// NewHelloRepository creates a new HelloRepository.
+func NewHelloRepository() HelloRepository {
+	return HelloRepository{}
+}
+
+func (h HelloRepository) ReadHelloMessageFor(codePairVisitor hello.CodePairVisitor) (string, error) {
+	return "Hello, " + codePairVisitor.Nickname + "!", nil
+}

backend-go/internal/server/routes.go

@@ -1,15 +1,20 @@
 package server
 
 import (
-	"fmt"
-	"net/http"
-
 	"github.com/labstack/echo/v4"
+	"github.com/yorkie-team/codepair/backend/internal/core/hello"
+	"github.com/yorkie-team/codepair/backend/internal/infra/database/mongo"
 )
 
 func RegisterRoutes(e *echo.Echo) {
-	e.GET("/", func(c echo.Context) error {
-		err := c.String(http.StatusOK, "Hello, World!")
-		return fmt.Errorf("error: %w", err)
-	})
+	// Repositories
+	helloRepository := mongo.NewHelloRepository()
+
+	// Services
+	helloService := hello.NewService(helloRepository)
+
+	// Handlers
+	helloHandler := hello.NewHandler(helloService)
+
+	e.POST("/hello", helloHandler.HelloCodePair)
 }

backend-go/internal/transport/rest/converter.go

@@ -0,0 +1,16 @@
+package rest
+
+import (
+	"errors"
+	"github.com/yorkie-team/codepair/backend/api/codepair/v1/models"
+)
+
+// ConvertErrorToResponse converts an error to a response.
+func ConvertErrorToResponse(err error) models.HttpExceptionResponse {
+	switch {
+	case errors.Is(err, InternalServerError):
+		return NewInternalServerErrorResponse()
+	default:
+		return NewInvalidJsonErrorResponse()
+	}
+}

backend-go/internal/transport/rest/error_responses.go

@@ -0,0 +1,28 @@
+package rest
+
+import (
+	"github.com/yorkie-team/codepair/backend/api/codepair/v1/models"
+	"net/http"
+)
+
+func newHttpExceptionResponse(statusCode int32, message string) models.HttpExceptionResponse {
+	return models.HttpExceptionResponse{
+		StatusCode: statusCode,
+		Message:    message,
+	}
+}
+
+// NewInvalidJsonErrorResponse creates a HttpExceptionResponse that represents an invalid JSON error.
+func NewInvalidJsonErrorResponse() models.HttpExceptionResponse {
+	return newHttpExceptionResponse(http.StatusBadRequest, "Invalid JSON")
+}
+
+// NewValidationErrorResponse creates a HttpExceptionResponse that represents a validation error.
+func NewValidationErrorResponse(reason string) models.HttpExceptionResponse {
+	return newHttpExceptionResponse(http.StatusBadRequest, reason)
+}
+
+// NewInternalServerErrorResponse creates a HttpExceptionResponse that represents a internal server error.
+func NewInternalServerErrorResponse() models.HttpExceptionResponse {
+	return newHttpExceptionResponse(http.StatusInternalServerError, "Internal Server Error")
+}

backend-go/internal/transport/rest/errors.go

@@ -0,0 +1,8 @@
+package rest
+
+import "errors"
+
+var (
+	// InternalServerError is an internal server error
+	InternalServerError = errors.New("internal server error")
+)

backend-go/internal/transport/rest/handler_utils.go

@@ -0,0 +1,35 @@
+package rest
+
+import (
+	"github.com/labstack/echo/v4"
+	"net/http"
+)
+
+type request interface {
+	Validate() error
+}
+
+// BindAndValidateRequest binds and validates the request.
+// If the request is invalid, it returns an error response.
+func BindAndValidateRequest(e echo.Context, req request) error {
+	if err := e.Bind(req); err != nil {
+		return e.JSON(http.StatusBadRequest, NewInvalidJsonErrorResponse())
+	}
+	if err := req.Validate(); err != nil {
+		return e.JSON(http.StatusBadRequest, NewValidationErrorResponse(err.Error()))
+	}
+	return nil
+}
+
+// NewErrorResponse handles the creation and response of an error.
+// It converts the provided error into a response structure and sends it as a JSON response.
+// The response status code is determined by the error's associated status.
+func NewErrorResponse(e echo.Context, err error) error {
+	resp := ConvertErrorToResponse(err)
+	return e.JSON(int(resp.StatusCode), ConvertErrorToResponse(err))
+}
+
+// NewOkResponse sends a JSON response with a status code of 200.
+func NewOkResponse(e echo.Context, resp interface{}) error {
+	return e.JSON(http.StatusOK, resp)
+}