Goでリポジトリを実装（「入門ドメイン駆動設計」Chapter5）

.
├── Makefile
├── db-migration.sh
├── docker
│   ├── go
│   │   └── Dockerfile
│   └── postgres
│       └── Dockerfile
├── docker-compose.yml
├── domain
│   └── model
│       └── user
│           ├── user.go
│           ├── user_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, 20 files

package user

import (
	"database/sql"
	"fmt"

	_ "github.com/lib/pq"
)

type UserRepositorier interface {
	FindByUserName(name *UserName) (*User, error)
	Save(user *User) error
}

type UserRepository struct {
	db *sql.DB
}

func NewUserRepository(db *sql.DB) (*UserRepository, error) {
	return &UserRepository{db: db}, nil
}

func (ur *UserRepository) FindByUserName(name *UserName) (user *User, err error) {
	tx, err := ur.db.Begin()
	if err != nil {
		return
	}
	defer func() {
		switch err {
		case nil:
			err = tx.Commit()
		default:
			tx.Rollback()
		}
	}()

	rows, err := tx.Query("SELECT id, name FROM users WHERE name = $1", name.value)
	if err != nil {
		return nil, &FindByUserNameQueryError{UserName: *name, Message: fmt.Sprintf("error is occured in userrepository.FindByUserName: %s", err), Err: err}
	}
	defer rows.Close()

	userId := &UserId{}
	userName := &UserName{}
	for rows.Next() {
		err := rows.Scan(&userId.value, &userName.value)
		if err != nil {
			return nil, err
		}
		user = &User{id: *userId, name: *userName}
	}

	err = rows.Err()
	if err != nil {
		return nil, err
	}

	return user, nil
}

type FindByUserNameQueryError struct {
	UserName UserName
	Message  string
	Err      error
}

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

func (ur *UserRepository) Save(user *User) (err error) {
	tx, err := ur.db.Begin()
	if err != nil {
		return
	}
	defer func() {
		switch err {
		case nil:
			err = tx.Commit()
		default:
			tx.Rollback()
		}
	}()

	_, err = tx.Exec("INSERT INTO users(id, name) VALUES ($1, $2)", user.id.value, user.name.value)
	if err != nil {
		return &SaveQueryRowError{UserName: user.name, Message: fmt.Sprintf("userrepository.Save err: %s", err), Err: err}
	}
	return nil
}

type SaveQueryRowError struct {
	UserName UserName
	Message  string
	Err      error
}

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

package user

type UserService struct {
	userRepository UserRepositorier
}

func NewUserService(userRepository UserRepositorier) (*UserService, error) {
	return &UserService{userRepository: userRepository}, nil
}

func (us *UserService) Exists(user *User) (bool, error) {
	user, err := us.userRepository.FindByUserName(user.Name())
	if err != nil {
		return false, err
	}
	return user != nil, nil
}

package user

type User struct {
	id   UserId
	name UserName
}

func NewUser(userId UserId, userName UserName) (*User, error) {
	return &User{id: userId, name: userName}, nil
}

func (user *User) Id() *UserId {
	return &user.id
}

func (user *User) Name() *UserName {
	return &user.name
}

package user

import (
	"fmt"
	"reflect"
)

type UserId struct {
	value string
}

func NewUserId(value string) (*UserId, error) {
	return &UserId{value: value}, nil
}

func (userId *UserId) Equals(other *UserId) bool {
	return reflect.DeepEqual(userId.value, other.value)
}

func (userId *UserId) String() string {
	return fmt.Sprintf("UserId [value: %s]", userId.value)
}

package user

import (
	"fmt"
	"reflect"
)

type UserName struct {
	value string
}

func NewUserName(value string) (*UserName, error) {
	if len(value) < 3 {
		return nil, fmt.Errorf("UserName is more than 3 characters.")
	}
	if len(value) > 20 {
		return nil, fmt.Errorf("UserName is less than 20 characters.")
	}
	return &UserName{value: value}, nil
}

func (userName *UserName) Equals(other UserName) bool {
	return reflect.DeepEqual(userName.value, other.value)
}

func (userName *UserName) String() string {
	return fmt.Sprintf("UserName: [value: %s]", userName.value)
}

package main

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

	"github.com/msksgm/go-itddd-05-repository/domain/model/user"
)

func main() {
	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 {
		log.Fatal(err)
	}
	if err := db.Ping(); err != nil {
		log.Fatal(err)
	}
	log.Println("successfully connected to database")

	err = CreateUser(db, "test-user", "test-user-id")
	if err != nil {
		log.Println(err)
	}
}

func CreateUser(db *sql.DB, name string, id string) (err error) {
	defer func() {
		if err != nil {
			err = &CreateUserError{Message: fmt.Sprintf("main.CreateUser err: %v", err), Err: err}
		}
	}()
	userName, err := user.NewUserName("username")
	if err != nil {
		return err
	}
	userId, err := user.NewUserId("userid")
	if err != nil {
		return err
	}
	newUser, err := user.NewUser(*userId, *userName)
	if err != nil {
		return err
	}

	userRepository, err := user.NewUserRepository(db)
	if err != nil {
		return err
	}

	userService, err := user.NewUserService(userRepository)
	if err != nil {
		return err
	}

	isExists, err := userService.Exists(newUser)
	if err != nil {
		return err
	}

	if isExists {
		return fmt.Errorf("the user %v is already exists", newUser)
	}

	if err := userRepository.Save(newUser); err != nil {
		return err
	}
	log.Println("test-user is successfully added in users table")
	return nil
}

type CreateUserError struct {
	Message string
	Err     error
}

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

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

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

> make run
docker compose exec app go run main.go
2022/04/07 22:19:24 successfully connected to database
2022/04/07 22:19:24 test-user is successfully added in users table

> make run
docker compose exec app go run main.go
2022/04/07 22:19:34 successfully connected to database
2022/04/07 22:19:34 main.CreateUser err: the user &{{userid} {username}} is already exists