Goと50%くらいの理解ではじめるクリーンというかオニオンなアーキテクチャ

.
├── README.md
├── application
│   └── service
├── common
│   ├── todo.go
│   └── user.go
├── domain
│   ├── model
│   └── repository
├── go.mod
├── go.sum
├── go_onion_architecture.db
├── infrastructure
│   ├── db.go
│   └── repository
├── main.go
├── mocks
│   ├── mock_repository
│   ├── registory
│   └── service
├── registory
│   └── registory.go
├── test
│   └── container.go
├── testdata
│   └── golden
└── userinterface
    ├── echo.go
    ├── handler
    ├── request
    └── response

package model

import "time"

type TodoId int64
type Title string
type Description string

type Todo struct {
	Id          TodoId      `json:"id"`
	Title       Title       `json:"title"`
	Description Description `json:"description"`
	CreatedAt   time.Time   `json:"created_at"`
	DeleteAt    time.Time   `json:"delete_at"`
}

package repository

import "github.com/JY8752/go-onion-architecture-sample/domain/model"

type TodoRepository interface {
	Create(model.UserId, model.Title, model.Description) (model.TodoId, error)
	List(model.UserId) ([]model.Todo, error)
	Delete(model.TodoId) error
}

package service

import (
	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	"github.com/JY8752/go-onion-architecture-sample/domain/repository"
)

type TodoService interface {
	Create(model.UserId, model.Title, model.Description) (model.TodoId, error)
	List(model.UserId) ([]model.Todo, error)
	Delete(model.TodoId) error
}

type todoService struct {
	todoRep repository.TodoRepository
}

func NewTodoService(todoRep repository.TodoRepository) TodoService {
	return &todoService{
		todoRep: todoRep,
	}
}

func (t *todoService) Create(userId model.UserId, title model.Title, description model.Description) (model.TodoId, error) {
	return t.todoRep.Create(userId, title, description)
}

func (t *todoService) List(userId model.UserId) ([]model.Todo, error) {
	return t.todoRep.List(userId)
}

func (t *todoService) Delete(todoId model.TodoId) error {
	return t.todoRep.Delete(todoId)
}

package infrastructure

import (
	"log"
	"time"

	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	"github.com/JY8752/go-onion-architecture-sample/domain/repository"
	db "github.com/JY8752/go-onion-architecture-sample/infrastructure"
)

type todoRepository struct {
	dbClient *db.DBClient
}

func NewTodoRepository(db *db.DBClient) repository.TodoRepository {
	return &todoRepository{
		dbClient: db,
	}
}

func (t *todoRepository) Create(userId model.UserId, title model.Title, description model.Description) (model.TodoId, error) {
	stmt, err := t.dbClient.Client.Prepare("INSERT INTO todos (user_id, title, description, created_at) VALUES (?, ?, ?, ?)")
	if err != nil {
		return 0, err
	}

	result, err := stmt.Exec(userId, title, description, time.Now())
	if err != nil {
		return 0, err
	}

	id, err := result.LastInsertId()
	if err != nil {
		return 0, err
	}

	return model.TodoId(id), nil
}

func (t *todoRepository) List(id model.UserId) ([]model.Todo, error) {
	stmt, err := t.dbClient.Client.Prepare("SELECT id, title, description, created_at FROM todos WHERE user_id = ? AND delete_at IS NULL")
	if err != nil {
		return nil, err
	}

	rows, err := stmt.Query(id)
	if err != nil {
		return nil, err
	}

	var todos []model.Todo
	for rows.Next() {
		var todo model.Todo
		err = rows.Scan(&todo.Id, &todo.Title, &todo.Description, &todo.CreatedAt)
		if err != nil {
			log.Printf("err: %s\n", err.Error())
			continue
		}
		todos = append(todos, todo)
	}

	return todos, nil
}

func (t *todoRepository) Delete(id model.TodoId) error {
	stmt, err := t.dbClient.Client.Prepare("UPDATE todos SET delete_at = ? WHERE id = ?")
	if err != nil {
		return err
	}

	_, err = stmt.Exec(time.Now(), id)
	if err != nil {
		return err
	}

	return nil
}

package handler

import (
	"log"

	"github.com/JY8752/go-onion-architecture-sample/common"
	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	"github.com/JY8752/go-onion-architecture-sample/registory"
	"github.com/JY8752/go-onion-architecture-sample/userinterface/request"
	"github.com/JY8752/go-onion-architecture-sample/userinterface/response"
	"github.com/labstack/echo/v4"
)

func TodoHandler(client *echo.Echo, registory registory.Registory) {
	client.POST("/:userId/todos", func(c echo.Context) error {
		// バリデーション
		_, err := common.GetUserId(c.Param("userId"))
		if err != nil {
			return err
		}

		var r request.CreateTodoRequest
		if err := c.Bind(&r); err != nil {
			return err
		}

		id, err := registory.TodoService().Create(
			model.UserId(r.UserId),
			model.Title(r.Title),
			model.Description(r.Description),
		)
		if err != nil {
			return err
		}

		return c.JSON(200, response.CreateTodoResponse{Id: id})
	})

	client.GET("/:userId/todos", func(c echo.Context) error {
		userId, err := common.GetUserId(c.Param("userId"))
		if err != nil {
			return err
		}

		todos, err := registory.TodoService().List(userId)
		if err != nil {
			log.Printf("err: %s\n", err.Error())
			return c.JSON(404, []model.Todo{})
		}

		return c.JSON(200, response.GetTodosResponse{Todos: todos})
	})

	client.DELETE("/todos/:id", func(c echo.Context) error {
		todoId, err := common.GetTodoId(c.Param("id"))
		if err != nil {
			return err
		}

		err = registory.TodoService().Delete(todoId)
		if err != nil {
			return err
		}

		return c.NoContent(204)
	})
}

package registory

import (
	service "github.com/JY8752/go-onion-architecture-sample/application/service"
	repository "github.com/JY8752/go-onion-architecture-sample/domain/repository"
	db "github.com/JY8752/go-onion-architecture-sample/infrastructure"
	infrastructure "github.com/JY8752/go-onion-architecture-sample/infrastructure/repository"
)

type Registory interface {
	UserRep() repository.UserRepository
	UserService() service.UserService
	TodoRep() repository.TodoRepository
	TodoService() service.TodoService
}

type registory struct {
	dbClient *db.DBClient
}

func NewRegistory(db *db.DBClient) Registory {
	return &registory{
		dbClient: db,
	}
}

func (r *registory) UserRep() repository.UserRepository {
	return infrastructure.NewUserRepository(r.dbClient)
}

func (r *registory) UserService() service.UserService {
	return service.NewUserService(r.UserRep())
}

func (r *registory) TodoRep() repository.TodoRepository {
	return infrastructure.NewTodoRepository(r.dbClient)
}

func (r *registory) TodoService() service.TodoService {
	return service.NewTodoService(r.TodoRep())
}

package main

import (
	db "github.com/JY8752/go-onion-architecture-sample/infrastructure"
	"github.com/JY8752/go-onion-architecture-sample/registory"
	ui "github.com/JY8752/go-onion-architecture-sample/userinterface"
)

func main() {
	// db
	db := db.NewDBClient("./go_onion_architecture.db")
	defer db.Client.Close()

	// registory
	registory := registory.NewRegistory(db)

	// echo
	apiClient := ui.NewApiClient(registory)
	apiClient.RegisterRoute()
	apiClient.Start()
}

package infrastructure_test

import (
	"os"
	"testing"

	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	"github.com/JY8752/go-onion-architecture-sample/domain/repository"
	db "github.com/JY8752/go-onion-architecture-sample/infrastructure"
	infrastructure "github.com/JY8752/go-onion-architecture-sample/infrastructure/repository"
	"github.com/stretchr/testify/assert"
)

var todoRep repository.TodoRepository

func TestMain(m *testing.M) {
	d := db.NewDBClient("file:infrastructure_test_db?mode=memory")
	todoRep = infrastructure.NewTodoRepository(d)

	code := m.Run()

	d.Client.Close() // Exitするとdeferが実行されないので
	os.Exit(code)
}

func TestCreate(t *testing.T) {
	// when
	userId := model.UserId(1)
	id, err := todoRep.Create(userId, "title", "description")
	if err != nil {
		t.Fatal(err)
	}

	// then
	todos, err := todoRep.List(userId)
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, 1, len(todos))
	assert.Equal(t, id, todos[0].Id)
	assert.Equal(t, model.Title("title"), todos[0].Title)
	assert.Equal(t, model.Description("description"), todos[0].Description)
}

package service_test

import (
	"testing"

	"github.com/JY8752/go-onion-architecture-sample/application/service"
	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	"github.com/JY8752/go-onion-architecture-sample/mocks/mock_repository"
	"github.com/golang/mock/gomock"
	"github.com/stretchr/testify/assert"
)

func TestCreate(t *testing.T) {
	// given
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	m := mock_repository.NewMockTodoRepository(ctrl)

	m.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(model.TodoId(1), nil)

	ts := service.NewTodoService(m)

	// when
	result, err := ts.Create(1, model.Title("title"), model.Description("description"))
	if err != nil {
		t.Fatal(err)
	}

	// when
	assert.Equal(t, model.TodoId(1), result)
}

package handler_test

import (
	"net/http/httptest"
	"strings"
	"testing"

	"github.com/JY8752/go-onion-architecture-sample/domain/model"
	mock_registory "github.com/JY8752/go-onion-architecture-sample/mocks/registory"
	mock_service "github.com/JY8752/go-onion-architecture-sample/mocks/service"
	"github.com/JY8752/go-onion-architecture-sample/userinterface/handler"
	"github.com/golang/mock/gomock"
	"github.com/labstack/echo/v4"
	"github.com/sebdah/goldie/v2"
	"github.com/stretchr/testify/assert"
)

const (
	goldenDir = "../../testdata/golden/"
)

func TestCreateUserHandler(t *testing.T) {
	// given
	e := echo.New()

	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	// エンドポイントの登録
	service := mock_service.NewMockUserService(ctrl)
	service.EXPECT().Create("user1").Return(model.UserId(1), nil)

	registory := mock_registory.NewMockRegistory(ctrl)
	registory.EXPECT().UserService().Return(service)

	handler.CreateUserHandler(e, registory)

	// リクエストの作成
	body := `{"name": "user1"}`
	w := httptest.NewRecorder()
	r := httptest.NewRequest(echo.POST, "/users", strings.NewReader(body))
	r.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
	defer r.Body.Close()

	// when
	e.ServeHTTP(w, r)

	// then
	assert.Equal(t, 200, w.Code)
	g := goldie.New(t, goldie.WithFixtureDir(goldenDir))
	g.Assert(t, t.Name(), w.Body.Bytes())
}