オニオンアーキテクチャの本質を理解したい

example-backend/
├── internal/
│   ├── application/     # アプリケーション層：ビジネスロジックの実装
│   │   ├── dto/
│   │   └── service/
│   ├── domain/          # ドメイン層：アプリケーションの中核
│   │   ├── model/ 
│   │   └── repository/
│   ├── infrastructure/  # インフラストラクチャ層：技術的な実装
│   │   ├── config/
│   │   ├── database/
│   │   ├── ldap/
│   │   └── persistence/
│   ├── interface/       # インターフェース層：外部との接点
│   │   ├── exception/
│   │   ├── handler/
│   │   ├── middleware/
│   │   └── router/
│   ├── registry/        # DIコンテナ
│   └── util/            # ユーティリティ関数
├── go.mod
├── go.sum
└── main.go              # エントリポイント

// interfaceを使わない実装
// user_service.go
type UserService struct {
  db *gorm.DB  // 具体的な実装に直接依存
}

func NewUserService(db *gorm.DB) *UserService {
  return &UserService{db: db}
}

// これはデータアクセス
func (s *UserService) GetUser(id uint) (*User, error) {
  var user User
  result := s.db.Where("id = ?", id).First(&user)
  return &user, result.Error
}

// これはビジネスロジック
func (s *UserService) UnlockUser(id uint) error {
  user, err := s.GetUser(id)
  if err != nil {
    return ErrUserNotFound
  }
  // ...
  return nil
}

// user_service_test.go
// テスト
func TestUserService_GetUser(t *testing.T) {
  // DB呼び出しを毎回定義
  db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
  if err != nil {
    t.Fatal(err)
  }
  
  service := NewUserService(db)
  // テストのたびにDBの準備が必要...
}

// 1. ドメインサービス層
type UserRepository interface {
  FindByID(id uint) (*model.User, error)
  UpdateLockStatus(user *model.User) error
}

// 2. インフラ層によるドメインサービス層の永続化
type userRepository struct {
  db *gorm.DB
}

func (r *userRepository) FindByID(id uint) (*model.User, error) {
  var user model.User
  result := r.db.First(&user, id)
  if result.Error != nil {
    if errors.Is(result.Error, gorm.ErrRecordNotFound) {
      return nil, repository.ErrUserNotFound
    }
    return nil, result.Error
  }
  return &user, nil
}

func (r *userRepository) UpdateLockStatus(user *model.User) error {
  result := r.db.Model(user).Updates(map[string]interface{}{
    "is_locked"     : user.IsLocked,
    "login_attempts": user.LoginAttempts,
  })
  return result.Error
}

// 3. アプリケーションサービス層のinterface
type UserService interface {
  GetUser(id uint) (*dto.UserResponse, error)
  UnlockUser(id uint) error
}

// 4. アプリケーションサービスの実装
type userService struct {
  repo repository.UserRepository
}

// アプリケーションサービスの初期化関数
func NewUserService(repo repository.UserRepository) UserService {
  return &userService{repo: repo}
}

func (s *userService) GetUser(id uint) (*dto.UserResponse, error) {
  // リポジトリを通してドメインモデルを取得
  user, err := s.repo.FindByID(id)
  if err != nil {
    return nil, err
  }

  // ドメインモデルからDTOへの変換
  return &dto.UserResponse{
    ID:       user.ID,
    UserID:   user.UserID,
    IsLocked: user.IsLocked,
  }, nil
}

func (s *userService) UnlockUser(id uint) error {
  user, err := s.repo.FindByID(id)
  if err != nil {
    return err
  }

  // ビジネスロジック
  user.LoginAttempts = 0
  user.IsLocked = false

  return s.repo.UpdateLockStatus(user)
}

// 5. インターフェースの実装
type UserHandler struct {
  service service.UserService
}

// ハンドラの初期化関数
func NewUserHandler(service service.UserService) *UserHandler {
  return &UserHandler{service: service}
}

// ...

// リポジトリのモック
type MockUserRepository struct {
  mock.Mock
}

// メソッドをモック化
func (m *MockUserRepository) FindByID(id uint) (*model.User, error) {
  args := m.Called(id)
  return args.Get(0).(*model.User), args.Error(1)
}

// サービスのテスト
func TestUserService_GetUser(t *testing.T) {
  mockRepo := new(MockUserRepository) // モックのリポジトリを作成
  service := NewUserService(mockRepo) // モックを注入して初期化

  // メソッドの引数と戻り値を指定
  mockRepo.On("FindByID", 1).Return(&model.User{
    ID:       1,
    Name:     "foo",
    Email:    "foo0001@example.com",
    Password: "example-pass",
  }, nil)

  // GetUser内で呼ばれるFindByIDがモックした出力を返す
  response, err := service.GetUser(1)
  assert.NoError(t, err)
  assert.Equal(t, "foo", response.Name)
}

// サービスのモック
type MockUserService struct {
  mock.Mock
}

func (m *MockUserService) GetUser(id uint) (*dto.UserResponse, error) {
  args := m.Called(id)
  return args.Get(0).(*dto.UserResponse), args.Error(1)
}

// ハンドラのテスト
func TestUserHandler_GetUser(t *testing.T) {
  mockService := new(MockUserService)
  handler := NewUserHandler(mockService)

  mockService.On("GetUser", 1).Return(&dto.UserResponse{
    ID:    1,
    Name:  "foo",
    Email: "foo0001@example.com",
  }, nil)

  response, err := handler.GetUser(1)
  assert.NoError(t, err)
  assert.Equal(t, "foo", response.Name)
}

type User struct {
  ID        uint
  Name      string
  Email     string
  Password  string
  CreatedAt time.Time
  UpdatedAt time.Time
}

type UserSearchResponse struct {
  ID        uint      `json:"id" example:"1"`
  Name      string    `json:"name" example:"foo"`
  Email     string    `json:"email" example:"foo0001@example.com"`
  CreatedAt time.Time `json:"created_at" example:"2024-01-01T00:00:00Z"`
  UpdatedAt time.Time `json:"updated_at" example:"2024-01-01T00:00:00Z"`
}

type UserVerifyRequest struct {
  Name     string `json:"name" example:"foo"`
  Password string `json:"password" example:"example-pass"`
}

type UserVerifyResponse struct {
  AccessToken string `json:"access_token" example:"eyJhbG..."`
  TokenType   string `json:"token_type" example:"Bearer"`
  ExpiresIn   int    `json:"expires_in" example:"10800"`
}

// application/dto/user_dto.go
type UserCreateRequest struct {
  Name     string `json:"name" example:"foo"`
  Email    string `json:"email" example:"foo0001@example.com"`
  Password string `json:"password" example:"example-pass"`
}

// ozzo-validation を使用
func (dto UserCreateRequest) Validate() error {
  return validation.ValidateStruct(&dto,
    validation.Field(&dto.Name, validation.Required.Error("ユーザー名は必須です")),
    validation.Field(&dto.Email, 
      validation.Required.Error("メールアドレスは必須です")),
    validation.Field(&dto.Password,
      validation.Required.Error("パスワードは必須です"),
      validation.Match(regexp.MustCompile(`^[a-zA-Z0-9!@#$%^&*()_+\-=\[\]{};:'",.<>/?]{10,}$`)).Error("パスワードは半角英数字と記号を含む10文字以上である必要があります")),
  )
}

// domain/model/user.go
type User struct {
  // ...
}

func isBcryptHash(value interface{}) error {
  // bcryptハッシュの評価関数
}

func (u User) Validate() error {
  return validation.ValidateStruct(&u,
    validation.Field(&u.Name,
      validation.Match(regexp.MustCompile(`^[a-zA-Z0-9-]*$`)).Error("ユーザー名は英数字とハイフンのみ使用可能です"),
    ),
    validation.Field(&u.Email,
      validation.Match(regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)).Error("有効なメールアドレスを入力してください"),
    ),
    validation.Field(&u.Password, validation.By(isBcryptHash)),
  )
}

// GetUser godoc
// @Summary ユーザー情報取得
// @Description 指定された`id`のユーザー情報を取得します。
// @Tags users
// @Accept json
// @Produce json
// @Param id path string true "ID"
// @Success 200 {object} dto.GetUserResponse
// @Failure 404 {object} dto.Error404Dto
// @Failure 500 {object} dto.Error500Dto
// @Router /users/{id} [get]
func (h *UserHandler) GetUser(c echo.Context) error {
  // ...
  return c.JSON(http.StatusOK, response)
}