Feat/hexa structure

.gitignore

@@ -0,0 +1 @@
+bin/api

Dockerfile

@@ -0,0 +1,35 @@
+# Stage 1: Build the Go binary
+FROM golang:1.22-alpine AS builder
+
+# Install necessary build tools
+RUN apk add --no-cache gcc musl-dev
+
+# Set the Current Working Directory inside the container
+WORKDIR /app
+
+# Copy go mod and sum files
+COPY go.mod go.sum ./
+
+# Download all dependencies
+RUN go mod download
+
+# Copy the entire project source into the container
+COPY . .
+
+# Build the Go app, specifying the directory containing the entry point
+RUN go build -o ./main ./cmd/api
+
+## Stage 2: A minimal image to run the Go binary
+FROM alpine:latest
+#
+## Set the Current Working Directory inside the container
+WORKDIR /root/
+#
+## Copy the Pre-built binary file from the builder stage
+COPY --from=builder /app/main .
+
+# Expose port 8080 to the outside world
+EXPOSE 8080
+
+# Command to run the executable
+CMD ["./main"]

Makefile

@@ -1,5 +1,8 @@
 test:
 	@go test ./... -v
 
-start:
-	@go run cmd/api/api.go
+build:
+	@go build -o bin/api cmd/api/api.go
+
+start: build
+	./bin/api

adapter/input/adapter_http/posts_controller.go

@@ -0,0 +1,96 @@
+package adapter_http
+
+import (
+	"github.com/dexfs/go-twitter-clone/adapter/input/model/request"
+	"github.com/dexfs/go-twitter-clone/adapter/input/model/response"
+	"github.com/dexfs/go-twitter-clone/config/validation"
+	"github.com/dexfs/go-twitter-clone/internal/core/port/input"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type postsController struct {
+	createPostUseCase   input.CreatePostUseCase
+	createRepostUseCase input.CreateRepostUseCase
+	createQuoteUseCase  input.CreateQuoteUseCase
+}
+
+func NewPostsController(createPostUseCase input.CreatePostUseCase, createRepostUseCase input.CreateRepostUseCase, createQuoteUseCase input.CreateQuoteUseCase) *postsController {
+	return &postsController{
+		createPostUseCase:   createPostUseCase,
+		createRepostUseCase: createRepostUseCase,
+		createQuoteUseCase:  createQuoteUseCase,
+	}
+}
+
+func (pc *postsController) CreatePost(c *gin.Context) {
+	createPostRequest := request.CreatePostRequest{}
+
+	if err := c.ShouldBindJSON(&createPostRequest); err != nil {
+		errRest := validation.RestError(err)
+		c.JSON(errRest.Code, errRest)
+		return
+	}
+
+	postDomain, err := pc.createPostUseCase.Execute(input.CreatePostUseCaseInput{
+		UserID:  createPostRequest.UserID,
+		Content: createPostRequest.Content,
+	})
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+		return
+	}
+
+	c.JSON(http.StatusCreated, response.CreatePostResponse{
+		PostID: postDomain.ID,
+	})
+}
+
+func (pc *postsController) CreateRepost(c *gin.Context) {
+	createRequest := request.RepostRequest{}
+
+	if err := c.ShouldBindJSON(&createRequest); err != nil {
+		errRest := validation.RestError(err)
+		c.JSON(errRest.Code, errRest)
+		return
+	}
+
+	postDomain, err := pc.createRepostUseCase.Execute(input.CreateRepostUseCaseInput{
+		PostID: createRequest.PostID,
+		UserID: createRequest.UserID,
+	})
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+		return
+	}
+
+	c.JSON(http.StatusCreated, response.CreatePostResponse{
+		PostID: postDomain.ID,
+	})
+}
+
+func (pc *postsController) CreateQuote(c *gin.Context) {
+	createRequest := request.QuoteRequest{}
+
+	if err := c.ShouldBindJSON(&createRequest); err != nil {
+		errRest := validation.RestError(err)
+		c.JSON(errRest.Code, errRest)
+		return
+	}
+
+	postDomain, err := pc.createQuoteUseCase.Execute(input.CreateQuoteUseCaseInput{
+		PostID: createRequest.PostID,
+		UserID: createRequest.UserID,
+		Quote:  createRequest.Quote,
+	})
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, err)
+	}
+
+	c.JSON(http.StatusCreated, response.CreatePostResponse{
+		PostID: postDomain.ID,
+	})
+}

adapter/input/adapter_http/users_controller.go

@@ -0,0 +1,70 @@
+package adapter_http
+
+import "C"
+import (
+	"github.com/dexfs/go-twitter-clone/adapter/input/model/request"
+	"github.com/dexfs/go-twitter-clone/adapter/input/model/response"
+	"github.com/dexfs/go-twitter-clone/config/validation"
+	"github.com/dexfs/go-twitter-clone/internal/core/domain"
+	"github.com/dexfs/go-twitter-clone/internal/core/port/input"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type usersController struct {
+	getUserInfoUseCase input.GetUserInfoUseCase
+	getUserFeedUseCase input.GetUserFeedUseCase
+}
+
+func NewUsersController(getUserInfoUseCase input.GetUserInfoUseCase, getUserFeedUseCase input.GetUserFeedUseCase) *usersController {
+	return &usersController{
+		getUserInfoUseCase,
+		getUserFeedUseCase,
+	}
+}
+
+func (uc *usersController) GetInfo(c *gin.Context) {
+	userInfoRequest := request.UserInfoRequest{}
+
+	if err := c.ShouldBindUri(&userInfoRequest); err != nil {
+		errRest := validation.RestError(err)
+		c.JSON(errRest.Code, errRest)
+		return
+	}
+	userFeedDomain, err := uc.getUserInfoUseCase.Execute(userInfoRequest.Username)
+	if err != nil {
+		c.JSON(err.Code, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, response.GetUserInfoResponse{
+		ID:        userFeedDomain.ID,
+		Username:  userFeedDomain.Username,
+		CreatedAt: userFeedDomain.CreatedAt.Format("2006-01-02"),
+	})
+}
+
+func (uc *usersController) GetFeed(c *gin.Context) {
+	userRequest := request.UserFeedRequest{}
+
+	if err := c.ShouldBindUri(&userRequest); err != nil {
+		errRest := validation.RestError(err)
+		c.JSON(errRest.Code, errRest)
+		return
+	}
+
+	userFeedDomain, err := uc.getUserFeedUseCase.Execute(userRequest.Username)
+	if err != nil {
+		c.JSON(err.Code, err)
+		return
+	}
+	var items []*domain.Post
+	if len(userFeedDomain) == 0 {
+		items = make([]*domain.Post, 0)
+	} else {
+		items = userFeedDomain
+	}
+	c.JSON(http.StatusOK, response.GetUserFeedResponse{
+		Items: items,
+	})
+}

adapter/input/model/request/post_create_request.go

@@ -0,0 +1,6 @@
+package request
+
+type CreatePostRequest struct {
+	UserID  string `json:"user_id" binding:"required,uuid4"`
+	Content string `json:"content" binding:"required,min=10,max=255"`
+}

adapter/input/model/request/quote_request.go

@@ -0,0 +1,7 @@
+package request
+
+type QuoteRequest struct {
+	UserID string `json:"user_id" binding:"required,uuid4"`
+	PostID string `json:"post_id" binding:"required,uuid4"`
+	Quote  string `json:"quote" binding:"required,min=10,max=100"`
+}

adapter/input/model/request/repost_request.go

@@ -0,0 +1,6 @@
+package request
+
+type RepostRequest struct {
+	UserID string `json:"user_id" binding:"required,uuid4"`
+	PostID string `json:"post_id" binding:"required,uuid4"`
+}

adapter/input/model/request/user_request.go

@@ -0,0 +1,9 @@
+package request
+
+type UserInfoRequest struct {
+	Username string `uri:"username" binding:"required,min=5,max=10,alphanum,lowercase"`
+}
+
+type UserFeedRequest struct {
+	Username string `uri:"username" binding:"required,min=5,max=10,alphanum,lowercase"`
+}

adapter/input/model/response/create_post_response.go

@@ -0,0 +1,5 @@
+package response
+
+type CreatePostResponse struct {
+	PostID string `json:"post_id"`
+}

adapter/input/model/response/user_response.go

@@ -0,0 +1,13 @@
+package response
+
+import "github.com/dexfs/go-twitter-clone/internal/core/domain"
+
+type GetUserInfoResponse struct {
+	ID        string `json:"id"`
+	Username  string `json:"username"`
+	CreatedAt string `json:"created_at"`
+}
+
+type GetUserFeedResponse struct {
+	Items []*domain.Post `json:"items"`
+}

adapter/input/model/rest_errors/rest_error.go

@@ -0,0 +1,61 @@
+package rest_errors
+
+import "net/http"
+
+type RestError struct {
+	Message string  `json:"message"`
+	Err     string  `json:"error"`
+	Code    int     `json:"code"`
+	Causes  []Cause `json:"causes"`
+}
+
+type Cause struct {
+	Field   string `json:"field"`
+	Message string `json:"message"`
+}
+
+func (r *RestError) Error() string {
+	return r.Message
+}
+
+func NewRestError(message string, err string, code int, causes []Cause) *RestError {
+	return &RestError{
+		Message: message,
+		Err:     err,
+		Code:    code,
+		Causes:  causes,
+	}
+}
+
+func NewBadRequestError(message string) *RestError {
+	return &RestError{
+		Message: message,
+		Err:     http.StatusText(http.StatusBadRequest),
+		Code:    http.StatusBadRequest,
+	}
+}
+
+func NewBadRequestValidationError(message string, causes []Cause) *RestError {
+	return &RestError{
+		Message: message,
+		Err:     http.StatusText(http.StatusBadRequest),
+		Code:    http.StatusBadRequest,
+		Causes:  causes,
+	}
+}
+
+func NewInternalServerError(message string) *RestError {
+	return &RestError{
+		Message: message,
+		Err:     http.StatusText(http.StatusInternalServerError),
+		Code:    http.StatusInternalServerError,
+	}
+}
+
+func NewNotFoundError(message string) *RestError {
+	return &RestError{
+		Message: message,
+		Err:     http.StatusText(http.StatusNotFound),
+		Code:    http.StatusNotFound,
+	}
+}

adapter/input/routes/gin_router.go

@@ -0,0 +1,62 @@
+package routes
+
+import (
+	"github.com/dexfs/go-twitter-clone/adapter/input/adapter_http"
+	"github.com/dexfs/go-twitter-clone/internal/core/port/output"
+	"github.com/dexfs/go-twitter-clone/internal/core/usecase"
+	"github.com/fvbock/endless"
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+type AppServer struct {
+	Router *gin.Engine
+	addr   string
+}
+
+func NewRouter(addr string) *AppServer {
+	//gin.SetMode(gin.DebugMode)
+	//gin.ForceConsoleColor()
+	r := gin.Default()
+	r.Use(cors.Default())
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+
+	return &AppServer{
+		Router: r,
+		addr:   addr,
+	}
+}
+
+func (s *AppServer) Run(userRepo output.UserPort, postRepo output.PostPort) error {
+	err := s.Router.SetTrustedProxies(nil)
+	if err != nil {
+		return err
+	}
+
+	s.InitUserResources(userRepo, postRepo)
+	s.InitPostResources(userRepo, postRepo)
+	return endless.ListenAndServe(s.addr, s.Router)
+}
+func (s *AppServer) InitUserResources(userRepo output.UserPort, postRepo output.PostPort) {
+	getUserInfoService, _ := usecase.NewGetUserInfoUseCase(userRepo)
+	getUserFeedUseCase, _ := usecase.NewGetUserFeedUseCase(userRepo, postRepo)
+
+	usersController := adapter_http.NewUsersController(getUserInfoService, getUserFeedUseCase)
+
+	s.Router.GET("/users/:username/info", usersController.GetInfo)
+	s.Router.GET("/users/:username/feed", usersController.GetFeed)
+}
+
+func (s *AppServer) InitPostResources(userRepo output.UserPort, postRepo output.PostPort) {
+	createPostUseCase, _ := usecase.NewCreatePostUseCase(postRepo, userRepo)
+	createRepostUseCase, _ := usecase.NewCreateRepostUseCase(postRepo, userRepo)
+	createQuoteUseCase, _ := usecase.NewCreateQuoteUseCase(postRepo, userRepo)
+
+	postsController := adapter_http.NewPostsController(createPostUseCase, createRepostUseCase, createQuoteUseCase)
+
+	s.Router.POST("/posts", postsController.CreatePost)
+	s.Router.POST("/posts/repost", postsController.CreateRepost)
+	s.Router.POST("/posts/quote", postsController.CreateQuote)
+}