class ProductCacheRepository {
  private readonly TTL_SECONDS = 1800; // 30分

  constructor(
    private redis: RedisClient,
    private db: Database,
  ) {}

  async getProduct(id: string): Promise<Product> {
    const cacheKey = `product:${id}`;

    // 1. キャッシュから取得を試みる
    try {
      const cached = await this.redis.get(cacheKey);
      if (cached) {
        return JSON.parse(cached) as Product;
      }
    } catch (error) {
      // Redis障害時はログを出してDBフォールバック
      console.warn(`Cache read failed for ${cacheKey}:`, error);
    }

    // 2. DBから取得
    const product = await this.db.findProduct(id);
    if (!product) {
      throw new NotFoundError(`Product ${id} not found`);
    }

    // 3. キャッシュに保存（失敗してもDBからの結果は返す）
    try {
      await this.redis.setex(
        cacheKey,
        this.TTL_SECONDS,
        JSON.stringify(product)
      );
    } catch (error) {
      console.warn(`Cache write failed for ${cacheKey}:`, error);
    }

    return product;
  }
}

ポイント：

• Redis障害時にもサービスが継続できるようtry-catchでラップ
• キャッシュはあくまで高速化の手段であり、障害時はDBにフォールバック

// Layer 1: ブラウザキャッシュ設定
const browserCacheConfig = {
  // 静的アセット（CSS, JS, 画像）
  staticAssets: {
    cacheControl: 'public, max-age=31536000, immutable',
    // ファイル名にハッシュを含める: style.abc123.css
  },
  // 商品ページHTML
  productPage: {
    cacheControl: 'private, max-age=0, must-revalidate',
    etag: true, // ETagで変更確認
  },
  // API レスポンス（商品詳細）
  productApi: {
    cacheControl: 'private, max-age=60, stale-while-revalidate=300',
    // 1分キャッシュ、5分間は古いデータを返しつつ裏で更新
  },
};

// Layer 2: CDNキャッシュ設定
const cdnConfig = {
  staticAssets: {
    ttl: 86400 * 365, // 1年（キャッシュバスティングで管理）
    compress: true,
  },
  productImages: {
    ttl: 86400,       // 24時間
    compress: true,
    imageOptimization: true,
  },
  productPageHtml: {
    ttl: 60,          // 1分
    varyHeaders: ['Accept-Encoding'],
  },
};

// Layer 3: アプリケーションキャッシュ（Redis）
const appCacheConfig = {
  productDetail: { ttl: 1800 },    // 30分
  productList: { ttl: 300 },       // 5分
  ranking: { ttl: 600 },           // 10分
  userSession: { ttl: 1800 },      // 30分
};

// Layer 4: データベースキャッシュ
const dbConfig = {
  sharedBuffers: '4GB',
  effectiveCacheSize: '12GB',
  // 商品テーブルのインデックスがバッファに乗るように設計
};

class ProductCacheInvalidator {
  async onProductUpdated(event: ProductUpdatedEvent): Promise<void> {
    const { productId, categoryId, oldPrice, newPrice } = event;

    // Step 1: アプリケーションキャッシュの無効化（即座に）
    await Promise.all([
      this.redis.del(`product:${productId}`),
      this.redis.del(`product-list:category:${categoryId}`),
      this.redis.del('ranking:sales'),
      this.redis.del('ranking:popular'),
    ]);

    // Step 2: CDNキャッシュの無効化
    await this.cdn.invalidate([
      `/products/${productId}`,
      `/api/products/${productId}`,
      `/categories/${categoryId}`,
    ]);

    // Step 3: ブラウザキャッシュは直接制御できない
    // → ETagの更新で次回アクセス時に検証
    // → WebSocket/SSEで接続中のユーザーに通知（オプション）

    // Step 4: 監査ログ
    await this.auditLog.record({
      action: 'cache_invalidation',
      trigger: 'product_price_change',
      productId,
      oldPrice,
      newPrice,
      timestamp: new Date(),
    });
  }
}

無効化の順序：

1. アプリケーションキャッシュ（Redis） → 最も制御しやすく即座に反映
2. CDNキャッシュ → API経由で無効化リクエスト（数秒かかる）
3. ブラウザキャッシュ → 直接制御不可、ETag/Cache-Controlで間接制御

class SaleEventCacheProtection {
  private locks = new Map<string, Promise<string>>();

  // Singleflight パターン: 同じキーへの同時リクエストを1つにまとめる
  async getWithSingleflight(
    key: string,
    fetchFn: () => Promise<string>,
    ttlSeconds: number
  ): Promise<string> {
    // 1. キャッシュ確認
    const cached = await this.redis.get(key);
    if (cached) return cached;

    // 2. 既に同じキーのフェッチが進行中なら、その結果を待つ
    if (this.locks.has(key)) {
      return this.locks.get(key)!;
    }

    // 3. フェッチを開始し、他のリクエストと共有
    const fetchPromise = (async () => {
      try {
        const result = await fetchFn();
        await this.redis.setex(key, ttlSeconds, result);
        return result;
      } finally {
        this.locks.delete(key);
      }
    })();

    this.locks.set(key, fetchPromise);
    return fetchPromise;
  }

  // セール前のキャッシュウォームアップ
  async warmupBeforeSale(): Promise<void> {
    const popularKeys = [
      'ranking:sales',
      'ranking:popular',
      'sale-products:page1',
      'sale-products:page2',
      'sale-products:page3',
    ];

    for (const key of popularKeys) {
      const data = await this.fetchFromDB(key);
      // TTLをセール開始後も持続するよう長めに設定
      await this.redis.setex(key, 7200, data); // 2時間
    }

    console.log(`Warmed up ${popularKeys.length} cache keys before sale`);
  }
}

対策のまとめ：

1. 事前ウォームアップ — セール開始前にキャッシュを温めておく
2. Singleflight — 同じキーのリクエストを1つにまとめる
3. TTLのジッター — 全キーが同時に切れないようランダムなオフセットを追加

# SpeedShop キャッシュ設計書

## 1. アーキテクチャ

ユーザー → [ブラウザキャッシュ] → [CDN (CloudFront)]
  → [ALB] → [App Server × 3] → [Redis Cluster]
  → [PostgreSQL (Primary + Read Replica)]

## 2. キャッシュ設定

| 層 | 対象 | TTL | 戦略 |
|----|------|-----|------|
| ブラウザ | 静的アセット | 1年(immutable) | キャッシュバスティング |
| ブラウザ | API | 1分 | stale-while-revalidate |
| CDN | 画像 | 24時間 | パス無効化 |
| CDN | HTML | 1分 | パス無効化 |
| Redis | 商品詳細 | 30分 | Cache-Aside + イベント無効化 |
| Redis | 一覧/ランキング | 5-10分 | Cache-Aside |
| Redis | セッション | 30分 | Write-Through |
| DB | クエリキャッシュ | 自動 | PostgreSQL設定 |

## 3. 無効化戦略
- 商品更新: イベントベース（Redis即削除 → CDN無効化）
- 在庫変更: Write-Through + 短TTL(10秒)
- ランキング: TTLベース(10分) + 定期バッチ更新

## 4. 障害時フォールバック
- Redis障害: DBフォールバック + アラート
- CDN障害: オリジン直接アクセス
- DB障害: キャッシュのみで読み取り継続（書き込み不可）

## 5. モニタリング指標
- キャッシュヒット率: 目標95%以上
- p99レイテンシ: 目標500ms以下
- Redis メモリ使用率: 閾値80%でアラート
- DB接続数: 閾値80%でアラート