// Authorization Code フロー 完全実装
 
// ① 認可リクエスト（クライアント → 認可サーバー）
function getAuthorizationUrl(state: string): string {
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: process.env.GITHUB_CLIENT_ID!,
    redirect_uri: 'https://myapp.com/callback',
    scope: 'read:user repo',
    state, // CSRF 防御用ランダム値
  });
 
  return `https://github.com/login/oauth/authorize?${params}`;
}
 
// ④⑤ コールバック処理（認可コード → トークン交換）
async function handleCallback(code: string, state: string) {
  // state の検証（CSRF 防御）
  if (state !== storedState) {
    throw new Error('Invalid state parameter');
  }
 
  // ⑤ トークン交換（サーバー側で実行 → client_secret を安全に使用）
  const tokenResponse = await fetch('https://github.com/login/oauth/access_token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify({
      client_id: process.env.GITHUB_CLIENT_ID,
      client_secret: process.env.GITHUB_CLIENT_SECRET, // サーバーのみ
      code,
      redirect_uri: 'https://myapp.com/callback',
    }),
  });
 
  const { access_token, refresh_token, scope, token_type } = await tokenResponse.json();
 
  // ⑦ リソース取得
  const userResponse = await fetch('https://api.github.com/user', {
    headers: { Authorization: `Bearer ${access_token}` },
  });
 
  return userResponse.json();
}

// 認可サーバーの内部実装（Express）
import express from 'express';
import crypto from 'crypto';
 
interface AuthorizationCode {
  code: string;
  clientId: string;
  userId: string;
  redirectUri: string;
  scope: string;
  codeChallenge?: string;
  codeChallengeMethod?: string;
  createdAt: Date;
  used: boolean;
}
 
interface TokenRecord {
  accessToken: string;
  refreshToken: string;
  clientId: string;
  userId: string;
  scope: string;
  accessTokenExpiresAt: Date;
  refreshTokenExpiresAt: Date;
  revoked: boolean;
}
 
class AuthorizationServer {
  private codes: Map<string, AuthorizationCode> = new Map();
  private tokens: Map<string, TokenRecord> = new Map();
  private refreshTokenIndex: Map<string, string> = new Map(); // refreshToken → accessToken
 
  // ① 認可エンドポイント
  async handleAuthorize(req: express.Request, res: express.Response) {
    const {
      response_type,
      client_id,
      redirect_uri,
      scope,
      state,
      code_challenge,
      code_challenge_method,
    } = req.query as Record<string, string>;
 
    // バリデーション
    if (response_type !== 'code') {
      return res.status(400).json({ error: 'unsupported_response_type' });
    }
 
    // クライアント検証
    const client = await this.getClient(client_id);
    if (!client) {
      return res.status(400).json({ error: 'invalid_client' });
    }
 
    // redirect_uri の完全一致確認
    if (!client.redirectUris.includes(redirect_uri)) {
      // redirect_uri が不正な場合はリダイレクトしてはいけない
      // （オープンリダイレクタ防止）
      return res.status(400).json({ error: 'invalid_redirect_uri' });
    }
 
    // スコープ検証
    const requestedScopes = scope.split(' ');
    const allowedScopes = requestedScopes.filter(s => client.allowedScopes.includes(s));
 
    // ユーザー認証済みか確認（未認証ならログイン画面へ）
    const user = req.session?.user;
    if (!user) {
      // ログイン画面にリダイレクト（認可パラメータを保持）
      return res.redirect(`/login?return_to=${encodeURIComponent(req.originalUrl)}`);
    }
 
    // 同意画面を表示（または以前の同意を確認）
    const existingConsent = await this.getConsent(user.id, client_id, allowedScopes);
    if (!existingConsent) {
      return res.render('consent', {
        client,
        scopes: allowedScopes,
        state,
        // 同意フォーム送信先
      });
    }
 
    // 認可コード生成
    const code = crypto.randomBytes(32).toString('hex');
    this.codes.set(code, {
      code,
      clientId: client_id,
      userId: user.id,
      redirectUri: redirect_uri,
      scope: allowedScopes.join(' '),
      codeChallenge: code_challenge,
      codeChallengeMethod: code_challenge_method,
      createdAt: new Date(),
      used: false,
    });
 
    // 認可コードは短寿命（30秒後に自動削除）
    setTimeout(() => this.codes.delete(code), 30 * 1000);
 
    // リダイレクト
    const callbackUrl = new URL(redirect_uri);
    callbackUrl.searchParams.set('code', code);
    if (state) callbackUrl.searchParams.set('state', state);
 
    res.redirect(302, callbackUrl.toString());
  }
 
  // ⑤ トークンエンドポイント
  async handleToken(req: express.Request, res: express.Response) {
    const { grant_type } = req.body;
 
    // Cache-Control ヘッダー（RFC 6749 Section 5.1）
    res.set('Cache-Control', 'no-store');
    res.set('Pragma', 'no-cache');
 
    switch (grant_type) {
      case 'authorization_code':
        return this.handleAuthorizationCodeGrant(req, res);
      case 'refresh_token':
        return this.handleRefreshTokenGrant(req, res);
      case 'client_credentials':
        return this.handleClientCredentialsGrant(req, res);
      default:
        return res.status(400).json({ error: 'unsupported_grant_type' });
    }
  }
 
  private async handleAuthorizationCodeGrant(
    req: express.Request,
    res: express.Response,
  ) {
    const { code, redirect_uri, code_verifier } = req.body;
    const { clientId, clientSecret } = this.extractClientCredentials(req);
 
    // クライアント認証
    const client = await this.authenticateClient(clientId, clientSecret);
    if (!client) {
      return res.status(401).json({ error: 'invalid_client' });
    }
 
    // 認可コード検証
    const authCode = this.codes.get(code);
    if (!authCode) {
      return res.status(400).json({ error: 'invalid_grant', error_description: 'Code not found or expired' });
    }
 
    // 使用済みチェック
    if (authCode.used) {
      // 認可コード再利用 = 攻撃の可能性
      // → 該当コードで発行された全トークンを無効化
      await this.revokeTokensByCode(code);
      return res.status(400).json({ error: 'invalid_grant', error_description: 'Code already used' });
    }
 
    // client_id 一致確認
    if (authCode.clientId !== clientId) {
      return res.status(400).json({ error: 'invalid_grant' });
    }
 
    // redirect_uri 一致確認
    if (authCode.redirectUri !== redirect_uri) {
      return res.status(400).json({ error: 'invalid_grant' });
    }
 
    // PKCE 検証
    if (authCode.codeChallenge) {
      if (!code_verifier) {
        return res.status(400).json({ error: 'invalid_grant', error_description: 'code_verifier required' });
      }
 
      const valid = this.verifyPKCE(
        code_verifier,
        authCode.codeChallenge,
        authCode.codeChallengeMethod || 'plain',
      );
 
      if (!valid) {
        return res.status(400).json({ error: 'invalid_grant', error_description: 'PKCE verification failed' });
      }
    }
 
    // コードを使用済みにマーク
    authCode.used = true;
 
    // トークン発行
    const tokens = await this.issueTokens(clientId, authCode.userId, authCode.scope);
 
    res.json({
      access_token: tokens.accessToken,
      token_type: 'Bearer',
      expires_in: 3600,
      refresh_token: tokens.refreshToken,
      scope: authCode.scope,
    });
  }
 
  // PKCE 検証
  private verifyPKCE(
    verifier: string,
    challenge: string,
    method: string,
  ): boolean {
    if (method === 'S256') {
      const hash = crypto.createHash('sha256').update(verifier).digest();
      const computed = hash
        .toString('base64')
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=+$/, '');
      return computed === challenge;
    }
    if (method === 'plain') {
      return verifier === challenge;
    }
    return false;
  }
 
  // クライアント認証情報の抽出
  private extractClientCredentials(req: express.Request): {
    clientId: string;
    clientSecret: string | null;
  } {
    // Basic 認証ヘッダーから取得
    const authHeader = req.headers.authorization;
    if (authHeader?.startsWith('Basic ')) {
      const decoded = Buffer.from(authHeader.slice(6), 'base64').toString();
      const [clientId, clientSecret] = decoded.split(':');
      return { clientId, clientSecret };
    }
 
    // POST ボディから取得
    return {
      clientId: req.body.client_id,
      clientSecret: req.body.client_secret || null,
    };
  }
 
  // トークン発行
  private async issueTokens(
    clientId: string,
    userId: string,
    scope: string,
  ): Promise<{ accessToken: string; refreshToken: string }> {
    const accessToken = crypto.randomBytes(32).toString('hex');
    const refreshToken = crypto.randomBytes(48).toString('hex');
 
    const record: TokenRecord = {
      accessToken,
      refreshToken,
      clientId,
      userId,
      scope,
      accessTokenExpiresAt: new Date(Date.now() + 3600 * 1000),    // 1時間
      refreshTokenExpiresAt: new Date(Date.now() + 30 * 24 * 3600 * 1000), // 30日
      revoked: false,
    };
 
    this.tokens.set(accessToken, record);
    this.refreshTokenIndex.set(refreshToken, accessToken);
 
    return { accessToken, refreshToken };
  }
}

// PKCE 実装
 
// code_verifier と code_challenge の生成
async function generatePKCE(): Promise<{ verifier: string; challenge: string }> {
  // code_verifier: 43〜128文字の暗号ランダム文字列
  const verifier = base64URLEncode(crypto.getRandomValues(new Uint8Array(32)));
 
  // code_challenge: SHA-256 ハッシュの Base64URL エンコード
  const encoder = new TextEncoder();
  const data = encoder.encode(verifier);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const challenge = base64URLEncode(new Uint8Array(hashBuffer));
 
  return { verifier, challenge };
}
 
function base64URLEncode(buffer: Uint8Array): string {
  return btoa(String.fromCharCode(...buffer))
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');
}
 
// ① 認可リクエスト（PKCE 付き）
async function startAuthFlow() {
  const { verifier, challenge } = await generatePKCE();
  const state = crypto.randomUUID();
 
  // verifier と state をセッションに保存
  sessionStorage.setItem('pkce_verifier', verifier);
  sessionStorage.setItem('oauth_state', state);
 
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: 'my-spa-client-id',
    redirect_uri: 'https://myapp.com/callback',
    scope: 'openid profile email',
    state,
    code_challenge: challenge,
    code_challenge_method: 'S256',
  });
 
  window.location.href = `https://auth.example.com/authorize?${params}`;
}
 
// ⑤ コールバック（PKCE + トークン交換）
async function handlePKCECallback(code: string, state: string) {
  // state 検証
  const storedState = sessionStorage.getItem('oauth_state');
  if (state !== storedState) throw new Error('Invalid state');
 
  const verifier = sessionStorage.getItem('pkce_verifier');
 
  // トークン交換（client_secret 不要）
  const response = await fetch('https://auth.example.com/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code,
      redirect_uri: 'https://myapp.com/callback',
      client_id: 'my-spa-client-id',
      code_verifier: verifier!,  // client_secret の代わり
    }),
  });
 
  const tokens = await response.json();
  // { access_token, refresh_token, id_token, token_type, expires_in }
 
  // クリーンアップ
  sessionStorage.removeItem('pkce_verifier');
  sessionStorage.removeItem('oauth_state');
 
  return tokens;
}

// Client Credentials フロー（基本）
async function getServiceToken(): Promise<string> {
  const response = await fetch('https://auth.example.com/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      // Basic 認証で client_id:client_secret を送信
      'Authorization': `Basic ${btoa(`${CLIENT_ID}:${CLIENT_SECRET}`)}`,
    },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      scope: 'read:data write:data',
    }),
  });
 
  const { access_token } = await response.json();
  return access_token;
}
 
// トークンキャッシュ付きの実装（本番向け）
class ServiceTokenManager {
  private token: string | null = null;
  private expiresAt: number = 0;
  private refreshPromise: Promise<string> | null = null;
  private readonly bufferSeconds = 60; // 期限の60秒前に更新
 
  constructor(
    private clientId: string,
    private clientSecret: string,
    private tokenUrl: string,
    private scope: string,
  ) {}
 
  async getToken(): Promise<string> {
    // キャッシュが有効ならそのまま返す
    if (this.token && Date.now() < this.expiresAt - this.bufferSeconds * 1000) {
      return this.token;
    }
 
    // 同時リクエスト時に重複リフレッシュを防止
    if (this.refreshPromise) {
      return this.refreshPromise;
    }
 
    this.refreshPromise = this.fetchNewToken();
    try {
      const token = await this.refreshPromise;
      return token;
    } finally {
      this.refreshPromise = null;
    }
  }
 
  private async fetchNewToken(): Promise<string> {
    const response = await fetch(this.tokenUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Authorization': `Basic ${Buffer.from(
          `${this.clientId}:${this.clientSecret}`,
        ).toString('base64')}`,
      },
      body: new URLSearchParams({
        grant_type: 'client_credentials',
        scope: this.scope,
      }),
    });
 
    if (!response.ok) {
      throw new Error(`Token request failed: ${response.status}`);
    }
 
    const data = await response.json();
    this.token = data.access_token;
    this.expiresAt = Date.now() + data.expires_in * 1000;
 
    return this.token;
  }
}
 
// マイクロサービス間通信での使用例
class OrderService {
  private tokenManager: ServiceTokenManager;
 
  constructor() {
    this.tokenManager = new ServiceTokenManager(
      process.env.ORDER_SERVICE_CLIENT_ID!,
      process.env.ORDER_SERVICE_CLIENT_SECRET!,
      'https://auth.example.com/token',
      'inventory:read inventory:reserve payments:create',
    );
  }
 
  async createOrder(orderData: OrderRequest): Promise<Order> {
    const token = await this.tokenManager.getToken();
 
    // 在庫サービスに問い合わせ
    const inventory = await fetch('https://inventory.internal/api/check', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ items: orderData.items }),
    });
 
    // 決済サービスに送信
    const payment = await fetch('https://payments.internal/api/charge', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        amount: orderData.total,
        currency: 'JPY',
      }),
    });
 
    // ...
  }
}

// private_key_jwt 認証の実装
import * as jose from 'jose';
 
async function getTokenWithPrivateKeyJWT(
  privateKey: jose.KeyLike,
  clientId: string,
  tokenUrl: string,
  scope: string,
): Promise<string> {
  // クライアントアサーション JWT の生成
  const assertion = await new jose.SignJWT({})
    .setProtectedHeader({ alg: 'RS256', typ: 'JWT' })
    .setIssuer(clientId)
    .setSubject(clientId)
    .setAudience(tokenUrl)
    .setIssuedAt()
    .setExpirationTime('5m')
    .setJti(crypto.randomUUID())
    .sign(privateKey);
 
  const response = await fetch(tokenUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      scope,
      client_id: clientId,
      client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
      client_assertion: assertion,
    }),
  });
 
  const data = await response.json();
  return data.access_token;
}

// Device Code フロー（CLI ツール等）
async function deviceCodeFlow() {
  // デバイス認可リクエスト
  const deviceRes = await fetch('https://auth.example.com/device/code', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      client_id: 'my-cli-app',
      scope: 'openid profile',
    }),
  });
 
  const {
    device_code,
    user_code,
    verification_uri,
    verification_uri_complete,
    expires_in,
    interval,
  } = await deviceRes.json();
 
  // ユーザーに表示
  console.log(`ブラウザで ${verification_uri} にアクセスし、`);
  console.log(`コード ${user_code} を入力してください。`);
 
  // ポーリングでトークン取得を試行
  let pollInterval = interval;
  const deadline = Date.now() + expires_in * 1000;
 
  while (Date.now() < deadline) {
    await sleep(pollInterval * 1000);
 
    const tokenRes = await fetch('https://auth.example.com/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
        device_code,
        client_id: 'my-cli-app',
      }),
    });
 
    const data = await tokenRes.json();
 
    if (data.error === 'authorization_pending') continue;
    if (data.error === 'slow_down') {
      pollInterval += 5; // ポーリング間隔を延長
      continue;
    }
    if (data.error) throw new Error(data.error_description);
 
    return data; // { access_token, refresh_token, ... }
  }
 
  throw new Error('Device code expired');
}
 
function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// リフレッシュトークン ローテーション実装
class TokenRefreshManager {
  private refreshing: Promise<TokenPair> | null = null;
 
  constructor(
    private tokenUrl: string,
    private clientId: string,
    private onTokenRefresh: (tokens: TokenPair) => void,
  ) {}
 
  // トークンリフレッシュ（重複防止付き）
  async refreshTokens(currentRefreshToken: string): Promise<TokenPair> {
    // 既にリフレッシュ中なら同じ Promise を返す
    if (this.refreshing) {
      return this.refreshing;
    }
 
    this.refreshing = this.doRefresh(currentRefreshToken);
 
    try {
      const tokens = await this.refreshing;
      this.onTokenRefresh(tokens);
      return tokens;
    } finally {
      this.refreshing = null;
    }
  }
 
  private async doRefresh(refreshToken: string): Promise<TokenPair> {
    const response = await fetch(this.tokenUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'refresh_token',
        refresh_token: refreshToken,
        client_id: this.clientId,
      }),
    });
 
    if (!response.ok) {
      const error = await response.json();
 
      if (error.error === 'invalid_grant') {
        // リフレッシュトークンが無効 → 再ログインが必要
        throw new TokenRefreshError('refresh_token_invalid', 'Re-authentication required');
      }
 
      throw new TokenRefreshError(error.error, error.error_description);
    }
 
    const data = await response.json();
    return {
      accessToken: data.access_token,
      refreshToken: data.refresh_token,  // ローテーション: 新しい refresh_token
      expiresIn: data.expires_in,
    };
  }
}
 
// HTTP クライアントとの統合（自動リフレッシュ）
class AuthenticatedHttpClient {
  private accessToken: string;
  private refreshToken: string;
  private expiresAt: number;
  private refreshManager: TokenRefreshManager;
 
  constructor(
    initialTokens: TokenPair,
    refreshManager: TokenRefreshManager,
  ) {
    this.accessToken = initialTokens.accessToken;
    this.refreshToken = initialTokens.refreshToken;
    this.expiresAt = Date.now() + initialTokens.expiresIn * 1000;
    this.refreshManager = refreshManager;
  }
 
  async fetch(url: string, options: RequestInit = {}): Promise<Response> {
    // アクセストークンの期限チェック
    await this.ensureValidToken();
 
    const response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${this.accessToken}`,
      },
    });
 
    // 401 が返ってきた場合はリフレッシュを試行
    if (response.status === 401) {
      try {
        await this.doTokenRefresh();
 
        // リトライ
        return fetch(url, {
          ...options,
          headers: {
            ...options.headers,
            'Authorization': `Bearer ${this.accessToken}`,
          },
        });
      } catch (error) {
        if (error instanceof TokenRefreshError) {
          // リフレッシュ失敗 → 再ログインが必要
          this.redirectToLogin();
        }
        throw error;
      }
    }
 
    return response;
  }
 
  private async ensureValidToken(): Promise<void> {
    // 有効期限の30秒前にプロアクティブにリフレッシュ
    if (Date.now() > this.expiresAt - 30 * 1000) {
      await this.doTokenRefresh();
    }
  }
 
  private async doTokenRefresh(): Promise<void> {
    const tokens = await this.refreshManager.refreshTokens(this.refreshToken);
    this.accessToken = tokens.accessToken;
    this.refreshToken = tokens.refreshToken;
    this.expiresAt = Date.now() + tokens.expiresIn * 1000;
  }
 
  private redirectToLogin(): void {
    window.location.href = '/login?reason=session_expired';
  }
}

// リフレッシュトークン ローテーション + リプレイ検知
class RefreshTokenStore {
  private redis: Redis;
 
  async storeToken(
    tokenFamily: string,
    refreshToken: string,
    userId: string,
    clientId: string,
    expiresIn: number,
  ): Promise<void> {
    const data = JSON.stringify({
      userId,
      clientId,
      tokenFamily,
      createdAt: Date.now(),
    });
 
    // リフレッシュトークン → データのマッピング
    await this.redis.setex(`rt:${refreshToken}`, expiresIn, data);
 
    // トークンファミリーに追加（リプレイ検知用）
    await this.redis.sadd(`tf:${tokenFamily}`, refreshToken);
    await this.redis.expire(`tf:${tokenFamily}`, expiresIn);
  }
 
  async useToken(refreshToken: string): Promise<{
    userId: string;
    clientId: string;
    tokenFamily: string;
  } | null> {
    const raw = await this.redis.get(`rt:${refreshToken}`);
 
    if (!raw) {
      // トークンが存在しない
      // → 有効期限切れ or 既に使用済み（リプレイ攻撃の可能性）
      return null;
    }
 
    const data = JSON.parse(raw);
 
    // トークンを使用済みにする（一度きりの使用）
    await this.redis.del(`rt:${refreshToken}`);
 
    return data;
  }
 
  // トークンファミリー全体を無効化（リプレイ検知時）
  async revokeFamily(tokenFamily: string): Promise<void> {
    const tokens = await this.redis.smembers(`tf:${tokenFamily}`);
 
    if (tokens.length > 0) {
      const keys = tokens.map(t => `rt:${t}`);
      await this.redis.del(...keys);
    }
 
    await this.redis.del(`tf:${tokenFamily}`);
  }
 
  // 特定ユーザーの全トークンを無効化
  async revokeAllForUser(userId: string): Promise<void> {
    // ユーザーのトークンファミリー一覧を取得して全無効化
    const families = await this.redis.smembers(`user_families:${userId}`);
    for (const family of families) {
      await this.revokeFamily(family);
    }
    await this.redis.del(`user_families:${userId}`);
  }
}

// スコープベースの認可チェック実装
class ScopeValidator {
  // スコープ文字列を配列に変換
  static parse(scopeString: string): string[] {
    return scopeString.split(' ').filter(Boolean);
  }
 
  // 要求されたスコープが付与されたスコープに含まれるか確認
  static hasScope(grantedScopes: string[], requiredScope: string): boolean {
    // 完全一致チェック
    if (grantedScopes.includes(requiredScope)) return true;
 
    // 階層チェック（"repo" は "repo:status" を包含）
    for (const granted of grantedScopes) {
      if (requiredScope.startsWith(granted + ':')) return true;
    }
 
    // ワイルドカードチェック
    for (const granted of grantedScopes) {
      if (granted.endsWith(':*')) {
        const prefix = granted.slice(0, -1);
        if (requiredScope.startsWith(prefix)) return true;
      }
    }
 
    return false;
  }
 
  // 複数スコープの確認（全て必要）
  static hasAllScopes(
    grantedScopes: string[],
    requiredScopes: string[],
  ): boolean {
    return requiredScopes.every(scope => this.hasScope(grantedScopes, scope));
  }
 
  // 複数スコープの確認（いずれか1つ）
  static hasAnyScope(
    grantedScopes: string[],
    requiredScopes: string[],
  ): boolean {
    return requiredScopes.some(scope => this.hasScope(grantedScopes, scope));
  }
}
 
// Express ミドルウェアとして使用
function requireScope(...scopes: string[]) {
  return (req: Request, res: Response, next: NextFunction) => {
    const tokenScopes = req.tokenPayload?.scope?.split(' ') || [];
 
    if (!ScopeValidator.hasAllScopes(tokenScopes, scopes)) {
      return res.status(403).json({
        error: 'insufficient_scope',
        required_scope: scopes.join(' '),
        granted_scope: tokenScopes.join(' '),
      });
    }
 
    next();
  };
}
 
// 使用例
app.get('/api/repos',
  authenticateBearer,
  requireScope('repos:read'),
  listReposHandler,
);
 
app.post('/api/repos/:id/deploy',
  authenticateBearer,
  requireScope('repos:write', 'deploy:execute'),
  deployHandler,
);

// トークン失効エンドポイントの実装
async function handleRevocation(req: express.Request, res: express.Response) {
  const { token, token_type_hint } = req.body;
  const { clientId } = extractClientCredentials(req);
 
  // RFC 7009: 成功時は常に 200 OK を返す
  // （トークンが存在しない場合も 200 を返す）
  res.status(200);
 
  try {
    if (token_type_hint === 'refresh_token' || !token_type_hint) {
      // リフレッシュトークンの失効を試行
      const revoked = await tokenStore.revokeRefreshToken(token, clientId);
      if (revoked) {
        // 関連するアクセストークンも失効
        await tokenStore.revokeAccessTokensByRefreshToken(token);
        return res.json({ revoked: true });
      }
    }
 
    if (token_type_hint === 'access_token' || !token_type_hint) {
      // アクセストークンの失効を試行
      await tokenStore.revokeAccessToken(token, clientId);
      return res.json({ revoked: true });
    }
 
    res.json({ revoked: false });
  } catch (error) {
    // エラーでも 200 OK を返す（RFC 7009 準拠）
    res.json({ revoked: false });
  }
}
 
// トークンイントロスペクション（RFC 7662）
async function handleIntrospection(req: express.Request, res: express.Response) {
  const { token } = req.body;
 
  const tokenData = await tokenStore.getToken(token);
 
  if (!tokenData || tokenData.revoked || tokenData.expiresAt < new Date()) {
    // 無効なトークン
    return res.json({ active: false });
  }
 
  // 有効なトークン
  res.json({
    active: true,
    scope: tokenData.scope,
    client_id: tokenData.clientId,
    username: tokenData.username,
    token_type: 'Bearer',
    exp: Math.floor(tokenData.expiresAt.getTime() / 1000),
    iat: Math.floor(tokenData.createdAt.getTime() / 1000),
    sub: tokenData.userId,
    aud: tokenData.audience,
    iss: 'https://auth.example.com',
  });
}

// BFF パターンの実装
import express from 'express';
import session from 'express-session';
 
const bff = express();
 
bff.use(session({
  secret: process.env.SESSION_SECRET!,
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,
    secure: true,
    sameSite: 'lax',
    maxAge: 24 * 60 * 60 * 1000,
  },
}));
 
// ログイン開始
bff.get('/bff/login', async (req, res) => {
  const { verifier, challenge } = await generatePKCE();
  const state = crypto.randomUUID();
 
  // セッションに保存
  req.session.pkceVerifier = verifier;
  req.session.oauthState = state;
 
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: process.env.OAUTH_CLIENT_ID!,
    redirect_uri: `${process.env.BFF_URL}/bff/callback`,
    scope: 'openid profile email',
    state,
    code_challenge: challenge,
    code_challenge_method: 'S256',
  });
 
  res.redirect(`${process.env.AUTH_URL}/authorize?${params}`);
});
 
// コールバック
bff.get('/bff/callback', async (req, res) => {
  const { code, state } = req.query as Record<string, string>;
 
  // state 検証
  if (state !== req.session.oauthState) {
    return res.status(403).json({ error: 'Invalid state' });
  }
 
  // トークン交換
  const tokenResponse = await fetch(`${process.env.AUTH_URL}/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'authorization_code',
      code,
      redirect_uri: `${process.env.BFF_URL}/bff/callback`,
      client_id: process.env.OAUTH_CLIENT_ID!,
      client_secret: process.env.OAUTH_CLIENT_SECRET!, // BFF は Confidential Client
      code_verifier: req.session.pkceVerifier,
    }),
  });
 
  const tokens = await tokenResponse.json();
 
  // トークンをセッションに保存（ブラウザには渡さない!）
  req.session.accessToken = tokens.access_token;
  req.session.refreshToken = tokens.refresh_token;
  req.session.tokenExpiresAt = Date.now() + tokens.expires_in * 1000;
 
  // クリーンアップ
  delete req.session.pkceVerifier;
  delete req.session.oauthState;
 
  // SPA にリダイレクト
  res.redirect(process.env.SPA_URL!);
});
 
// API プロキシ
bff.all('/bff/api/*', async (req, res) => {
  if (!req.session.accessToken) {
    return res.status(401).json({ error: 'Not authenticated' });
  }
 
  // トークンの期限チェック + リフレッシュ
  if (Date.now() > req.session.tokenExpiresAt - 30000) {
    try {
      const refreshed = await refreshTokens(req.session.refreshToken);
      req.session.accessToken = refreshed.access_token;
      req.session.refreshToken = refreshed.refresh_token;
      req.session.tokenExpiresAt = Date.now() + refreshed.expires_in * 1000;
    } catch {
      return res.status(401).json({ error: 'Session expired' });
    }
  }
 
  // API にプロキシ
  const apiPath = req.path.replace('/bff/api', '');
  const apiResponse = await fetch(`${process.env.API_URL}${apiPath}`, {
    method: req.method,
    headers: {
      'Authorization': `Bearer ${req.session.accessToken}`,
      'Content-Type': req.headers['content-type'] || 'application/json',
    },
    body: ['POST', 'PUT', 'PATCH'].includes(req.method)
      ? JSON.stringify(req.body)
      : undefined,
  });
 
  const data = await apiResponse.json();
  res.status(apiResponse.status).json(data);
});
 
// ログアウト
bff.post('/bff/logout', async (req, res) => {
  // トークン失効
  if (req.session.refreshToken) {
    await fetch(`${process.env.AUTH_URL}/revoke`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Authorization': `Basic ${Buffer.from(
          `${process.env.OAUTH_CLIENT_ID}:${process.env.OAUTH_CLIENT_SECRET}`,
        ).toString('base64')}`,
      },
      body: new URLSearchParams({
        token: req.session.refreshToken,
        token_type_hint: 'refresh_token',
      }),
    });
  }
 
  // セッション破棄
  req.session.destroy(() => {
    res.clearCookie('connect.sid');
    res.json({ success: true });
  });
});