エラーの伝播

func (s *paymentService) Process(ctx context.Context, p *payment.ProcessPayload) (*payment.ProcessResult, error) {
    // ビジネスロジックは以下のような方法でエラーを返すことができます：
    
    // 1. 生成されたヘルパー関数の使用（ErrorResult用）
    if !hasEnoughFunds(p.Amount) {
        return nil, payment.MakeInsufficientFunds(
            fmt.Errorf("口座残高 %d が必要額 %d を下回っています", balance, p.Amount))
    }
    
    // 2. カスタムエラー型の返却
    if err := validateCard(p.Card); err != nil {
        return nil, &payment.PaymentError{
            Name:    "card_expired",
            Message: err.Error(),
        }
    }
    
    // 3. 下流サービスからのエラーの伝播
    result, err := s.processor.ProcessPayment(ctx, p)
    if err != nil {
        // 外部エラーをドメインエラーでラップ
        return nil, payment.MakeProcessingFailed(fmt.Errorf("決済処理エラー: %w", err))
    }
    
    return result, nil
}

var _ = Service("payment", func() {
    // ここで定義されたエラーは名前でマッチング
    Error("insufficient_funds")
    Error("card_expired")
    Error("processing_failed", func() {
        // プロパティはエラー処理に影響を与える
        Temporary()
        Fault()
    })
})

var _ = Service("payment", func() {
    HTTP(func() {
        // HTTPマッピングルール
        Response("insufficient_funds", StatusPaymentRequired)
        Response("card_expired", StatusUnprocessableEntity)
        Response("processing_failed", StatusServiceUnavailable)
    })
    
    GRPC(func() {
        // gRPCマッピングルール
        Response("insufficient_funds", CodeFailedPrecondition)
        Response("card_expired", CodeInvalidArgument)
        Response("processing_failed", CodeUnavailable)
    })
})

client := payment.NewClient(endpoint)
result, err := client.Process(ctx, payload)
if err != nil {
    switch e := err.(type) {
    case *payment.InsufficientFundsError:
        // 残高不足の処理（エラープロパティを含む）
        if e.Temporary {
            return retry(ctx, payload)
        }
        return promptForTopUp(e.Message)
        
    case *payment.CardExpiredError:
        // 期限切れカードの処理
        return promptForNewCard(e.Message)
        
    case *payment.ProcessingFailedError:
        // 処理失敗の処理
        if e.Temporary {
            return retryWithBackoff(ctx, payload)
        }
        return reportSystemError(e)
        
    default:
        // 予期しないエラーの処理
        return handleUnknownError(err)
    }
}

// 1. ビジネスロジック（サービス実装）
if !hasEnoughFunds(amount) {
    return nil, payment.MakeInsufficientFunds(
        fmt.Errorf("残高 %d が必要額 %d を下回っています", balance, amount))
}

// 2. エラー定義（設計）
var _ = Service("payment", func() {
    Error("insufficient_funds", func() {
        Description("口座の残高が不足しています")
        Temporary()  // チャージ後に再試行可能
    })
})

// 3. トランスポートマッピング（設計）
HTTP(func() {
    Response("insufficient_funds", StatusPaymentRequired)
})

// 4. クライアント受信
result, err := client.Process(ctx, payload)
if err != nil {
    if e, ok := err.(*payment.InsufficientFundsError); ok {
        if e.Temporary {
            // retry-afterヘッダーの期間待機
            time.Sleep(retryAfter)
            return retry(ctx, payload)
        }
    }
}