サービス分割:

1. Passenger Service
   責務: 乗客のプロフィール管理、認証
   データ: passengers, payment_methods
   技術: TypeScript + PostgreSQL

2. Driver Service
   責務: ドライバーのプロフィール、車両情報
   データ: drivers, vehicles, documents
   技術: TypeScript + PostgreSQL

3. Ride Service
   責務: 乗車のライフサイクル管理
   データ: rides, ride_status_history
   技術: TypeScript + PostgreSQL（Saga Orchestrator）

4. Matching Service
   責務: ドライバーと乗客のマッチング
   データ: matching_requests, match_results
   技術: Go + Redis（高速位置検索）

5. Location Service
   責務: リアルタイム位置情報管理
   データ: driver_locations (揮発性)
   技術: Go + Redis GEO（地理空間インデックス）

6. Pricing Service
   責務: 運賃計算（距離、時間、需要に基づく動的価格）
   データ: pricing_rules, surge_zones
   技術: TypeScript + DynamoDB

7. Payment Service
   責務: 決済処理、返金
   データ: payments, refunds, receipts
   技術: Java + PostgreSQL（高い信頼性）

8. Rating Service
   責務: 評価管理
   データ: ratings, reviews
   技術: TypeScript + DynamoDB

9. Notification Service
   責務: プッシュ通知、SMS
   データ: notification_logs
   技術: TypeScript + SQS

同期通信:
  乗客 → Pricing Service: 運賃見積もり（即座に結果が必要）
  Ride Service → Matching Service: マッチングリクエスト（5秒以内）
  Ride Service → Location Service: ドライバー位置の取得

非同期通信（イベント）:
  ride.requested      → Matching Serviceがマッチング開始
  ride.matched        → Notification Serviceが乗客・ドライバーに通知
  ride.started        → Location Serviceが追跡開始
  ride.completed      → Payment Serviceが決済開始
                      → Rating Serviceが評価リクエスト
  payment.completed   → Notification Serviceが領収書送信
  payment.failed      → Ride Serviceが決済リトライ

メッセージブローカー: Apache Kafka
  Topics:
  - ride-events (key: rideId, partitions: 24)
  - payment-events (key: rideId, partitions: 12)
  - location-events (key: driverId, partitions: 48)
  - notification-events (partitions: 12)

// Orchestration を選択
// 理由: ステップが多く、タイムアウト管理が重要。
//        乗車のライフサイクル全体を1箇所で管理したい。

const rideSagaSteps: SagaStep[] = [
  {
    name: "createRide",
    execute: async (ctx) => {
      const ride = await rideService.create({
        passengerId: ctx.passengerId,
        pickup: ctx.pickup,
        destination: ctx.destination,
      });
      return { rideId: ride.id };
    },
    compensate: async (ctx) => {
      await rideService.cancel(ctx.rideId, "SYSTEM_CANCELLED");
    },
    timeout: 5000,
  },
  {
    name: "estimatePrice",
    execute: async (ctx) => {
      const estimate = await pricingService.estimate({
        pickup: ctx.pickup,
        destination: ctx.destination,
      });
      return { estimatedFare: estimate.fare };
    },
    compensate: async () => { /* 読み取りのみ、補償不要 */ },
    timeout: 3000,
  },
  {
    name: "matchDriver",
    execute: async (ctx) => {
      const match = await matchingService.findDriver({
        rideId: ctx.rideId,
        pickup: ctx.pickup,
        maxWaitSeconds: 30,
      });
      return { driverId: match.driverId };
    },
    compensate: async (ctx) => {
      await matchingService.releaseDriver(ctx.driverId);
    },
    timeout: 30000, // マッチングは最大30秒待つ
  },
  {
    name: "confirmRide",
    execute: async (ctx) => {
      await rideService.confirm(ctx.rideId, ctx.driverId);
      // → ride.matched イベントが発行される
      return {};
    },
    compensate: async (ctx) => {
      await rideService.cancel(ctx.rideId, "MATCH_CANCELLED");
    },
    timeout: 5000,
  },
  // 乗車完了後（ドライバーがride.completedをトリガー）
  {
    name: "processPayment",
    execute: async (ctx) => {
      const payment = await paymentService.charge({
        rideId: ctx.rideId,
        passengerId: ctx.passengerId,
        amount: ctx.finalFare,
        idempotencyKey: `ride-${ctx.rideId}-payment`,
      });
      return { paymentId: payment.id };
    },
    compensate: async (ctx) => {
      if (ctx.paymentId) {
        await paymentService.refund(ctx.paymentId);
      }
    },
    timeout: 10000,
  },
  {
    name: "notifyCompletion",
    execute: async (ctx) => {
      await notificationService.send(ctx.passengerId, {
        type: "RIDE_COMPLETED",
        rideId: ctx.rideId,
        fare: ctx.finalFare,
      });
      return {};
    },
    compensate: async () => { /* 通知は不可逆、最後に配置 */ },
    timeout: 5000,
  },
];

// Write Model: ドライバー位置（1秒ごとに更新）
// → Redis GEO（揮発性OK、Write性能最優先）
class LocationWriteService {
  async updateLocation(driverId: string, lat: number, lng: number): Promise<void> {
    await this.redis.geoadd("driver_locations", lng, lat, driverId);
    // Outbox不要: 位置情報はロスト許容（次の更新で上書き）
  }
}

// Read Model 1: 周辺ドライバーの地図表示
// → Redis GEO から直接クエリ（Write = Read、分離不要）
class NearbyDriversQuery {
  async find(lat: number, lng: number, radiusKm: number): Promise<Driver[]> {
    return await this.redis.georadius("driver_locations", lng, lat, radiusKm, "km");
  }
}

// Write Model: 乗車記録
// → PostgreSQL（ACID、正規化）
// Read Model: 乗車履歴画面
// → DynamoDB（userId で高速クエリ）
interface RideHistoryReadModel {
  passengerId: string;
  rideId: string;
  driverName: string;
  driverPhoto: string;
  vehicleInfo: string;
  pickup: string;
  destination: string;
  fare: number;
  rating: number;
  date: string;
}

// プロジェクション: ride.completed → 乗車履歴Read Model更新
class RideHistoryProjection {
  async handleRideCompleted(event: RideCompletedEvent): Promise<void> {
    const driver = await this.driverService.getDriver(event.data.driverId);
    await this.dynamodb.put({
      TableName: "ride_history",
      Item: {
        passengerId: event.data.passengerId,
        rideId: event.data.rideId,
        driverName: driver.name,
        driverPhoto: driver.photoUrl,
        vehicleInfo: `${driver.vehicle.make} ${driver.vehicle.model}`,
        pickup: event.data.pickupAddress,
        destination: event.data.destinationAddress,
        fare: event.data.fare,
        date: event.metadata.timestamp,
      },
    });
  }
}

テスト戦略:

1. Contract Tests
   - Ride Service ↔ Payment Service の決済API契約
   - Ride Service ↔ Matching Service のマッチングAPI契約
   - イベントスキーマ（ride.completed等）の契約

2. Chaos Engineering
   実験1: Matching Service停止
     仮説: 配車リクエストがタイムアウトし「ドライバーが見つかりません」表示
     検証: 乗客UIにエラーメッセージ、データ不整合なし

   実験2: Payment Service 高遅延（10秒）
     仮説: 乗車完了は即座に表示、決済は非同期で再処理
     検証: 決済が最終的に完了、二重課金なし

   実験3: Kafka障害
     仮説: Outboxパターンでイベントが保持され、復旧後に処理
     検証: イベントのロストなし

3. オブザーバビリティ
   - 分散トレーシング: rideIdをcorrelation IDとして全サービスで追跡
   - メトリクス: マッチング所要時間、決済成功率、ドライバー稼働率
   - ログ: 構造化ログ + ELKで集約

                    [Mobile App (Passenger)]    [Mobile App (Driver)]
                              │                        │
                         [API Gateway]                 │
                         ├─ 認証 (JWT)                 │
                         ├─ レート制限                  │
                         └─ WebSocket (位置情報)        │
                              │                        │
           ┌──────────────────┼────────────────────────┘
           │                  │
      [Passenger]        [Ride Service]            [Driver]
      [Service]          (Saga Orchestrator)        [Service]
           │               │    │    │                │
           │          同期  │    │    │ 同期           │
           │    ┌──────────┘    │    └──────────┐     │
           │    │               │               │     │
      [Pricing]          [Matching]         [Location]
      [Service]          [Service]          [Service]
                              │             [Redis GEO]
                              │
                         [Kafka]
                    ┌────────┼────────┐
                    │        │        │
              [Payment]  [Rating]  [Notification]
              [Service]  [Service] [Service]

      Write DB: PostgreSQL (rides, payments)
      Read DB:  DynamoDB (乗車履歴), Redis (位置, マッチング)
      イベント: Kafka (ride-events, payment-events, location-events)
      監視: OpenTelemetry + Jaeger + Prometheus + Grafana