Goで集約を実装（「ドメイン駆動設計入門」Chapter12）

.
├── Makefile
├── application
│   └── circleapplicationservice.go
├── db-migration.sh
├── docker
│   ├── go
│   │   └── Dockerfile
│   └── postgres
│       └── Dockerfile
├── docker-compose.yml
├── domain
│   └── model
│       ├── circle
│       │   ├── circle.go
│       │   ├── circle_test.go
│       │   ├── circleid.go
│       │   ├── circleid_test.go
│       │   ├── circlename.go
│       │   ├── circlename_test.go
│       │   ├── circlerepository.go
│       │   ├── circleservice.go
│       │   └── circleservice_test.go
│       └── user
│           ├── user.go
│           ├── user_test.go
│           ├── userid.go
│           ├── userid_test.go
│           ├── username.go
│           └── username_test.go
├── go.mod
├── go.sum
├── infrastructure
│   └── persistence
│       ├── circlerepository.go
│       └── circlerepository_test.go
├── main.go
└── migrations
    ├── 000001_user.down.sql
    ├── 000001_user.up.sql
    ├── 000002_userCircles.down.sql
    ├── 000002_userCircles.up.sql
    ├── 000003_circles.down.sql
    └── 000003_circles.up.sql

11 directories, 32 files

package circle

import "github.com/msksgm/go-itddd-12-aggregate/domain/model/user"

type Circle struct {
	Id      CircleId
	Name    CircleName
	Owner   user.User
	Members []user.User
}

func NewCircle(id CircleId, name CircleName, owner user.User, members []user.User) (*Circle, error) {
	return &Circle{Id: id, Name: name, Owner: owner, Members: members}, nil
}

func (circle *Circle) IsFull() bool {
	return len(circle.Members) >= 29
}

type CircleIsFullError struct {
	CircleId CircleId
	Message  string
}

func (cife *CircleIsFullError) Error() string {
	return cife.Message
}

func (circle *Circle) Join(newMember *user.User) error {
	if circle.IsFull() {
		return &CircleIsFullError{CircleId: circle.Id, Message: "cannnot join member because the circle is full"}
	}
	circle.Members = append(circle.Members, *newMember)
	return nil
}

type MemberIsNotFoundError struct {
	MemberId user.UserId
	Message  string
}

func (minfe *MemberIsNotFoundError) Error() string {
	return minfe.Message
}

func (circle *Circle) ChangeMemberName(memberId *user.UserId, changedUserName *user.UserName) error {
	for i, member := range circle.Members {
		if member.Id().Equals(memberId) {
			circle.Members[i].ChangeName(*changedUserName)
			return nil
		}
	}
	return &MemberIsNotFoundError{MemberId: *memberId, Message: "member is not found"}
}

package application

import (
	"fmt"
	"log"

	"github.com/msksgm/go-itddd-12-aggregate/domain/model/circle"
	"github.com/msksgm/go-itddd-12-aggregate/domain/model/user"
)

type CircleApplicationService struct {
	circleRepository circle.CircleRepositorier
	circleService    circle.CircleService
}

func NewCircleApplicationService(circleRepository circle.CircleRepositorier, circleService circle.CircleService) (*CircleApplicationService, error) {
	return &CircleApplicationService{circleRepository: circleRepository, circleService: circleService}, nil
}

func (cas *CircleApplicationService) Register(circleName string) (err error) {
	defer func() {
		if err != nil {
			err = &RegisterError{Name: circleName, Message: fmt.Sprintf("circleapplicationservice.Register err: %s", err), Err: err}
		}
	}()
	newCircleId, err := circle.NewCircleId("test-circle-id")
	if err != nil {
		return nil
	}
	newCircleName, err := circle.NewCircleName(circleName)
	if err != nil {
		return nil
	}

	ownerId, err := user.NewUserId("ownerId")
	if err != nil {
		return nil
	}
	ownerName, err := user.NewUserName("ownerName")
	if err != nil {
		return nil
	}
	owner, err := user.NewUser(*ownerId, *ownerName)
	if err != nil {
		return nil
	}

	memberId, err := user.NewUserId("memberId")
	if err != nil {
		return nil
	}
	memberName, err := user.NewUserName("memberName")
	if err != nil {
		return nil
	}
	member, err := user.NewUser(*memberId, *memberName)
	if err != nil {
		return nil
	}

	members := []user.User{*owner, *member}
	newCircle, err := circle.NewCircle(*newCircleId, *newCircleName, *owner, members)
	if err != nil {
		return nil
	}
	isCircleExists, err := cas.circleService.Exists(newCircle)
	if err != nil {
		return err
	}
	if isCircleExists {
		return fmt.Errorf("circleName of %s is already exists.", circleName)
	}

	if err := cas.circleRepository.Save(newCircle); err != nil {
		return err
	}
	log.Println("success fully saved")
	return nil
}

type RegisterError struct {
	Name    string
	Message string
	Err     error
}

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

type CircleData struct {
	Id      circle.CircleId
	Name    circle.CircleName
	Owner   user.User
	Members []user.User
}

func (cas *CircleApplicationService) Get(circleName string) (_ *CircleData, err error) {
	targetName, err := circle.NewCircleName(circleName)
	if err != nil {
		return nil, err
	}
	circle, err := cas.circleRepository.FindByCircleName(targetName)
	if err != nil {
		return nil, err
	}
	return &CircleData{Id: circle.Id, Name: circle.Name, Owner: circle.Owner, Members: circle.Members}, nil
}

package main

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

	_ "github.com/lib/pq"

	"github.com/msksgm/go-itddd-12-aggregate/application"
	"github.com/msksgm/go-itddd-12-aggregate/domain/model/circle"
	"github.com/msksgm/go-itddd-12-aggregate/infrastructure/persistence"
)

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

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

	circleRepository, err := persistence.NewCircleRepository(db)
	if err != nil {
		panic(err)
	}
	circleService, err := circle.NewCircleService(circleRepository)
	if err != nil {
		panic(err)
	}
	circleApplicationService, err := application.NewCircleApplicationService(circleRepository, *circleService)
	if err != nil {
		panic(err)
	}

	flag.Parse()
	log.Println(*command)
	switch *command {
	case "register":
		if err := circleApplicationService.Register("test-circle-name"); err != nil {
			log.Println(err)
		}
	case "get":
		circleData, err := circleApplicationService.Get("test-circle-name")
		if err != nil {
			log.Println(err)
		}
		log.Println(circleData)
	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 (15.619ms)
2/u userCircles (18.026ms)
3/u circles (23.721ms)

BEGIN;

CREATE TABLE IF NOT EXISTS users(
    id VARCHAR(255) PRIMARY KEY,
    name VARCHAR(255) NOT NULL UNIQUE
);

INSERT INTO users(id, name) VALUES ('ownerId', 'ownerName');
INSERT INTO users(id, name) VALUES ('userId', 'userName');

COMMIT;

> make run usecase=register
docker compose exec app go run main.go -usecase=register
2022/04/27 22:34:46 successfully connected to database
2022/04/27 22:34:46 register
2022/04/27 22:34:46 success fully saved

> make run usecase=register
docker compose exec app go run main.go -usecase=register
2022/04/27 22:35:18 successfully connected to database
2022/04/27 22:35:18 register
2022/04/27 22:35:18 circleapplicationservice.Register err: circleName of test-circle-name is already exists.

> make run usecase=get
docker compose exec app go run main.go -usecase=get
2022/04/27 22:38:56 successfully connected to database
2022/04/27 22:38:56 get
2022/04/27 22:38:56 &{{test-circle-id} {test-circle-name} {{ownerId} {ownerName}} [{{ownerId} {ownerName}}]}

	rows, err := tx.Query("SELECT c.id, c.circlename, c.owner_id, u.id, u.name from circles c JOIN userCircles uc ON c.id = uc.circle_id JOIN users u ON u.id = uc.user_id WHERE c.circlename = $1", circleName.Value)
	if err != nil {
		return nil, &FindByCircleNameQueryError{CircleName: circleName.Value, Message: "error is occured in circlerepository.FindByCircleName", Err: err}
	}
	defer rows.Close()

	// DB から取得した値を構造体の属性にマッピングするには、構造体の属性を公開する必要があった
	findCircleId := &circle.CircleId{}
	findCircleName := &circle.CircleName{}
	ownerId := &user.UserId{}
	memberId := &user.UserId{}
	memberName := &user.UserName{}
	members := []user.User{}
	for rows.Next() {
		err := rows.Scan(&findCircleId.Value, &findCircleName.Value, &ownerId.Value, &memberId.Value, &memberName.Value)
		if err != nil {
			return nil, err
		}
		members = append(members, user.User{UserId: *memberId, Name: *memberName})
	}
	err = rows.Err()
	if err != nil {
		return nil, err
	}