最近の記事

// 悪い例（セッターが存在）
type Account struct {
    balance float64
}

func (a *Account) GetBalance() float64 {
    return a.balance
}

func (a *Account) SetBalance(amount float64) {
    a.balance = amount  // 検証なしで変更可能
}

func main() {
    acc := &Account{balance: 1000}
    acc.SetBalance(-500)  // 不正な状態を作成可能
}

// 良い例（ゲッターのみ、状態変更はドメインメソッド）
type Account struct {
    balance float64
}

func NewAccount(initialBalance float64) (*Account, error) {
    if initialBalance < 0 {
        return nil, errors.New("initial balance must be positive")
    }
    return &Account{balance: initialBalance}, nil
}

func (a *Account) Balance() float64 {
    return a.balance
}

func (a *Account) Deposit(amount float64) error {
    if amount <= 0 {
        return errors.New("deposit amount must be positive")
    }
    a.balance += amount
    return nil
}

func (a *Account) Withdraw(amount float64) error {
    if amount <= 0 {
        return errors.New("withdraw amount must be positive")
    }
    if a.balance < amount {
        return errors.New("insufficient balance")
    }
    a.balance -= amount
    return nil
}

// 悪い例（コメントなし、または冗長）
func ProcessOrder(order Order) error {
    // この関数はOrderを受け取り、それを処理し、エラーがあればエラーを返します
    // 引数: order - 処理するOrder型の変数
    // 戻り値: error - エラーがあればerror、なければnil
    // ...
}

// 良い例
// ProcessOrder は注文を検証して保存し、確認メールを送信する
func ProcessOrder(order Order) error {
    // ...
}

// CalculateTax は商品価格に対する消費税額を計算する
func CalculateTax(price float64) float64 {
    return price * 0.1
}

// FetchActiveUsers はアクティブなユーザー一覧をデータベースから取得する
func FetchActiveUsers() ([]User, error) {
    // ...
}

// GenerateInvoicePDF は注文データからPDF形式の請求書を生成する
// pdfOptions: マージン、フォントサイズなど細かい制御が必要な場合のみコメント
func GenerateInvoicePDF(order Order, pdfOptions PDFOptions) ([]byte, error) {
    // ...
}

// 悪い例（具体的な実装に依存）
type MySQLDatabase struct{}

func (db *MySQLDatabase) Query(sql string) []Row {
    // MySQL固有の実装
    return nil
}

type UserService struct {
    db *MySQLDatabase  // 具体的な実装に依存
}

// 良い例（インターフェースに依存）
type Database interface {
    Query(sql string) []Row
}

type MySQLDatabase struct{}

func (db *MySQLDatabase) Query(sql string) []Row {
    return nil
}

type UserService struct {
    db Database  // インターフェースに依存
}

func NewUserService(db Database) *UserService {
    return &UserService{db: db}
}

// 悪い例（ドメインロジックがutilに配置）
package util

func CalculateOrderTotal(items []Item) float64 {
    total := 0.0
    for _, item := range items {
        total += item.Price * float64(item.Quantity)
    }
    // 1万円以上で送料無料（ドメインルール）
    if total < 10000 {
        total += 500  // 送料
    }
    return total
}

// 良い例（ドメインロジックはドメイン層に配置）
package domain

type Order struct {
    items []Item
}

func (o *Order) CalculateTotal() float64 {
    subtotal := 0.0
    for _, item := range o.items {
        subtotal += item.Price * float64(item.Quantity)
    }

    shippingFee := o.calculateShippingFee(subtotal)
    return subtotal + shippingFee
}

func (o *Order) calculateShippingFee(subtotal float64) float64 {
    const freeShippingThreshold = 10000
    const standardShippingFee = 500

    if subtotal >= freeShippingThreshold {
        return 0
    }
    return standardShippingFee
}

// utilパッケージは汎用機能のみ
package util

func FormatCurrency(amount float64) string {
    return fmt.Sprintf("¥%.0f", amount)
}

// 悪い例（暗黙的な依存）
type OrderService struct {
    // 依存関係が明示されていない
}

func (s *OrderService) CreateOrder(items []Item) error {
    // 内部でグローバルなhelperを使用
    db := GetGlobalDB()  // 暗黙的な依存
    logger := GetGlobalLogger()  // 暗黙的な依存

    total := calculateTotal(items)
    if err := db.Insert(total); err != nil {
        logger.Error(err)
        return err
    }
    return nil
}

// 良い例（明示的な依存注入）
type OrderService struct {
    db     Database
    logger Logger
    pricer PriceCalculator
}

func NewOrderService(db Database, logger Logger, pricer PriceCalculator) *OrderService {
    return &OrderService{
        db:     db,
        logger: logger,
        pricer: pricer,
    }
}

func (s *OrderService) CreateOrder(items []Item) error {
    total := s.pricer.CalculateTotal(items)

    if err := s.db.Insert(total); err != nil {
        s.logger.Error(err)
        return err
    }

    return nil
}

// 悪い例（検証がエンティティ外部）
type Order struct {
    Amount float64
    Status string
}

func ValidateOrder(order Order) error {
    if order.Amount < 0 {
        return errors.New("amount must be positive")
    }
    if order.Status != "pending" && order.Status != "completed" {
        return errors.New("invalid status")
    }
    return nil
}

// 良い例（検証がエンティティ内部）
type Order struct {
    amount float64
    status string
}

func NewOrder(amount float64) (*Order, error) {
    o := &Order{amount: amount, status: "pending"}
    if err := o.validate(); err != nil {
        return nil, err
    }
    return o, nil
}

func (o *Order) validate() error {
    if o.amount < 0 {
        return errors.New("amount must be positive")
    }
    return nil
}

func (o *Order) Complete() error {
    if o.status != "pending" {
        return errors.New("only pending orders can be completed")
    }
    o.status = "completed"
    return nil
}

# ./production/providers.tf (ルートモジュール)
provider "aws" {
  region = "ap-northeast-1"

  default_tags {
    tags = {
      Environment = "production"
      ManagedBy   = "Terraform"
    }
  }
}

# ./production/versions.tf (ルートモジュール)
terraform {
  required_version = "= 1.9.8"

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "= 5.75.1"
    }
  }
}

# ./modules/networking/outputs.tf

output "vpc_id" {
  description = "作成されたVPCのID"
  value       = aws_vpc.main.id
}