Goで実装するヘッドレスワークフローエンジン：Transactional OutboxパターンとWebhook配信の実践

// 問題のあるコード例
func ConfirmOrder(ctx context.Context, orderID string) error {
    tx, _ := db.BeginTx(ctx, nil)

    // 1. DB更新
    _, err := tx.Exec("UPDATE orders SET status = 'confirmed' WHERE id = ?", orderID)
    if err != nil {
        tx.Rollback()
        return err
    }

    // 2. 外部API呼び出し（トランザクション内で危険）
    resp, err := paymentClient.Charge(orderID)
    if err != nil {
        tx.Rollback() // DBはロールバックされるが、課金は実行済みかもしれない
        return err
    }

    return tx.Commit()
}

// Outboxパターンを使った安全なコード
func ConfirmOrder(ctx context.Context, orderID string) error {
    tx, _ := db.BeginTx(ctx, nil)

    // 1. ビジネスデータを更新
    _, err := tx.Exec("UPDATE orders SET status = 'confirmed' WHERE id = ?", orderID)
    if err != nil {
        tx.Rollback()
        return err
    }

    // 2. Outboxにイベントを挿入（同一トランザクション）
    event := OutboxEvent{
        AggregateType: "Order",
        AggregateID:   orderID,
        EventType:     "OrderConfirmed",
        Payload:       `{"order_id":"` + orderID + `"}`,
    }
    _, err = tx.Exec(
        "INSERT INTO outbox (aggregate_type, aggregate_id, event_type, payload) VALUES (?, ?, ?, ?)",
        event.AggregateType, event.AggregateID, event.EventType, event.Payload,
    )
    if err != nil {
        tx.Rollback()
        return err
    }

    return tx.Commit() // アトミックにコミット
}

// SSRF対策を施したWebhook配信
func isInternalIP(host string) bool {
    ip := net.ParseIP(host)
    if ip == nil {
        return false
    }
    return ip.IsPrivate() || ip.IsLoopback()
}

func deliverWebhook(url string, payload []byte, secret string) error {
    parsedURL, _ := url.Parse(url)
    if isInternalIP(parsedURL.Hostname()) {
        return errors.New("internal IPs are not allowed")
    }

    // HMAC署名を生成
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(payload)
    signature := hex.EncodeToString(mac.Sum(nil))

    req, _ := http.NewRequest("POST", url, bytes.NewReader(payload))
    req.Header.Set("X-Signature", signature)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode >= 400 {
        return fmt.Errorf("webhook failed: %d", resp.StatusCode)
    }
    return nil
}

type State string

const (
    StatePending   State = "pending"
    StateApproved  State = "approved"
    StateRejected  State = "rejected"
    StateCancelled State = "cancelled"
)

// 許可される状態遷移を定義
var transitions = map[State][]State{
    StatePending:  {StateApproved, StateRejected, StateCancelled},
    StateApproved: {StateCancelled},
    StateRejected: {},
    StateCancelled: {},
}

func (s State) CanTransitionTo(next State) bool {
    allowed, ok := transitions[s]
    if !ok {
        return false
    }
    for _, a := range allowed {
        if a == next {
            return true
        }
    }
    return false
}