Goでアプリケーションサービスを実装（「ドメイン駆動設計入門」Chapter6）

.
├── Makefile
├── db-migration.sh
├── docker
│   ├── go
│   │   └── Dockerfile
│   └── postgres
│       └── Dockerfile
├── docker-compose.yml
├── domain
│   └── model
│       └── user
│           ├── user.go
│           ├── user_test.go
│           ├── userapplicationservice.go
│           ├── userapplicationservice_test.go
│           ├── userid.go
│           ├── userid_test.go
│           ├── username.go
│           ├── username_test.go
│           ├── userrepository.go
│           ├── userrepository_test.go
│           ├── userservice.go
│           └── userservice_test.go
├── go.mod
├── go.sum
├── main.go
└── migrations
    ├── 000001_user.down.sql
    └── 000001_user.up.sql

7 directories, 22 files

package user

import (
	"fmt"
	"log"
	// "github.com/google/uuid"
)

type UserApplicationService struct {
	userRepository UserRepositorier
	userService    UserService
}

func NewUserApplicationService(userRepository UserRepositorier, userService UserService) (*UserApplicationService, error) {
	return &UserApplicationService{userRepository: userRepository, userService: userService}, nil
}

func (uas *UserApplicationService) Register(name string) (err error) {
	defer func() {
		if err != nil {
			err = &RegisterError{Name: name, Message: fmt.Sprintf("userapplicationservice.Register err: %s", err), Err: err}
		}
	}()
	userName, err := NewUserName(name)
	if err != nil {
		return err
	}

	// uuidV4 := uuid.New().String()
	uuidV4 := "test-id"
	userId, err := NewUserId(uuidV4)
	if err != nil {
		return err
	}

	user, err := NewUser(*userId, *userName)
	if err != nil {
		return err
	}

	isUserExists, err := uas.userService.Exists(user)
	if err != nil {
		return err
	}
	if isUserExists {
		return fmt.Errorf("user name of %s is already exists.", name)
	}

	if err := uas.userRepository.Save(user); err != nil {
		return err
	}

	log.Printf("user name of %s is successfully saved", name)
	return nil
}

type RegisterError struct {
	Name    string
	Message string
	Err     error
}

func (err *RegisterError) Error() string {
	return err.Message
}

type UserData struct {
	Id   string
	Name string
}

func (uas *UserApplicationService) Get(userId string) (_ *UserData, err error) {
	defer func() {
		if err != nil {
			err = &GetError{UserId: userId, Message: fmt.Sprintf("userapplicationservice.Get err: %s", err), Err: err}
		}
	}()
	targetId, err := NewUserId(userId)
	if err != nil {
		return nil, err
	}
	user, err := uas.userRepository.FindByUserId(targetId)
	if err != nil {
		return nil, err
	}

	if user == nil {
		return nil, nil
	}
	userData := &UserData{Id: user.id.value, Name: user.name.value}
	return userData, nil
}

type GetError struct {
	UserId  string
	Message string
	Err     error
}

func (err *GetError) Error() string {
	return err.Message
}

type UserUpdateCommand struct {
	Id   string
	Name string
}

func (uas *UserApplicationService) Update(command UserUpdateCommand) error {
	targetId, err := NewUserId(command.Id)
	if err != nil {
		return err
	}
	user, err := uas.userRepository.FindByUserId(targetId)
	if err != nil {
		return err
	}
	if user == nil {
		return fmt.Errorf("user is not found")
	}

	if name := command.Name; name != "" {
		newUserName, err := NewUserName(name)
		if err != nil {
			return err
		}
		user.ChangeName(*newUserName)

		isExists, err := uas.userService.Exists(user)
		if err != nil {
			return err
		}
		if isExists {
			return fmt.Errorf("user name of %s is already exists.", name)
		}
	}

	if err := uas.userRepository.Update(user); err != nil {
		return err
	}

	log.Println("successfully updated")
	return nil
}

type UserDeleteCommand struct {
	Id string
}

func (uas *UserApplicationService) Delete(command UserDeleteCommand) error {
	targetId, err := NewUserId(command.Id)
	if err != nil {
		return err
	}
	user, err := uas.userRepository.FindByUserId(targetId)
	if err != nil {
		return err
	}
	if user == nil {
		return nil
	}

	if err := uas.userRepository.Delete(user); err != nil {
		return err
	}
	log.Println("successfully deleted")
	return nil
}

package main

import (
	"database/sql"
	"flag"
	"fmt"
	"log"
	"os"

	"github.com/msksgm/go-itddd-06-applicationservice/domain/model/user"
)

var command = flag.String("usecase", "", "usercase of application")

func main() {
	// DBに接続
	uri := fmt.Sprintf("postgres://%s/%s?sslmode=disable&user=%s&password=%s&port=%s&timezone=Asia/Tokyo",
		os.Getenv("DB_HOST"), os.Getenv("DB_NAME"), os.Getenv("DB_USER"), os.Getenv("DB_PASSWORD"), os.Getenv("DB_PORT"))
	db, err := sql.Open("postgres", uri)
	if err != nil {
		panic(err)
	}
	if err := db.Ping(); err != nil {
		panic(err)
	}
	log.Println("successfully connected to database")

	// アプリケーションサービスにリポジトリとドメインサービスを挿入
	userRepository, err := user.NewUserRepository(db)
	if err != nil {
		panic(err)
	}
	userService, err := user.NewUserService(userRepository)
	if err != nil {
		panic(err)
	}
	userApplicationService, err := user.NewUserApplicationService(userRepository, *userService)
	if err != nil {
		panic(err)
	}

	// ユースケースの実行
	flag.Parse()
	log.Println(*command)
	switch *command {
	case "register":
		if err := userApplicationService.Register("test-user"); err != nil {
			log.Println(err)
		}
	case "get":
		userData, err := userApplicationService.Get("test-id")
		if err != nil {
			log.Println(err)
		}
		log.Println(userData)
	case "update":
		userUpdateCommand := &user.UserUpdateCommand{Id: "test-id", Name: "test-updated-user"}
		if err := userApplicationService.Update(*userUpdateCommand); err != nil {
			log.Println(err)
		}
	case "delete":
		userDeleteCommand := &user.UserDeleteCommand{Id: "test-id"}
		if err := userApplicationService.Delete(*userDeleteCommand); err != nil {
			log.Println(err)
		}
	default:
		log.Printf("%s is not command. choose in ('register', 'get', 'update', 'delete')", *command)
	}
}

> make up
docker compose up -d
# 完了までまつ

> make run-migration
docker compose exec app bash db-migration.sh
1/u user (13.817ms)

> make run usecase=register
docker compose exec app go run main.go -usecase=register
2022/04/21 23:17:11 successfully connected to database
2022/04/21 23:17:11 register
2022/04/21 23:17:11 user name of test-user is successfully saved

> make run usecase=register
docker compose exec app go run main.go -usecase=register
2022/04/21 23:19:07 successfully connected to database
2022/04/21 23:19:07 register
2022/04/21 23:19:07 userapplicationservice.Register err: user name of test-user is already exists.

> make run usecase=get
docker compose exec app go run main.go -usecase=get
2022/04/21 23:20:24 successfully connected to database
2022/04/21 23:20:24 get
2022/04/21 23:20:24 &{test-id test-user}

> make run usecase=update
docker compose exec app go run main.go -usecase=update
2022/04/21 23:21:26 successfully connected to database
2022/04/21 23:21:26 update
2022/04/21 23:21:26 successfully updated

> make run usecase=get
docker compose exec app go run main.go -usecase=get
2022/04/21 23:22:24 successfully connected to database
2022/04/21 23:22:24 get
2022/04/21 23:22:24 &{test-id test-updated-user}

> make run usecase=delete
docker compose exec app go run main.go -usecase=delete
2022/04/21 23:23:52 successfully connected to database
2022/04/21 23:23:52 delete
2022/04/21 23:23:52 successfully deleted