// pricing-strategy.ts — Strategy パターンの基本形
interface PricingStrategy {
  readonly name: string;
  calculate(basePrice: number): number;
  getDescription(): string;
}
 
class RegularPricing implements PricingStrategy {
  readonly name = "regular";
  calculate(basePrice: number): number {
    return basePrice;
  }
  getDescription(): string {
    return "通常価格（割引なし）";
  }
}
 
class PremiumPricing implements PricingStrategy {
  readonly name = "premium";
  calculate(basePrice: number): number {
    return Math.round(basePrice * 0.9); // 10%割引
  }
  getDescription(): string {
    return "プレミアム会員価格（10%OFF）";
  }
}
 
class StudentPricing implements PricingStrategy {
  readonly name = "student";
  calculate(basePrice: number): number {
    return Math.round(basePrice * 0.7); // 30%割引
  }
  getDescription(): string {
    return "学生価格（30%OFF）";
  }
}
 
class SeniorPricing implements PricingStrategy {
  readonly name = "senior";
  calculate(basePrice: number): number {
    return Math.round(basePrice * 0.8); // 20%割引
  }
  getDescription(): string {
    return "シニア価格（20%OFF）";
  }
}
 
// Context: ショッピングカート
class ShoppingCart {
  private items: { name: string; price: number; quantity: number }[] = [];
  private pricingStrategy: PricingStrategy;
 
  constructor(pricingStrategy: PricingStrategy = new RegularPricing()) {
    this.pricingStrategy = pricingStrategy;
  }
 
  setPricingStrategy(strategy: PricingStrategy): void {
    this.pricingStrategy = strategy;
    console.log(`Pricing changed to: ${strategy.getDescription()}`);
  }
 
  addItem(name: string, price: number, quantity: number = 1): void {
    this.items.push({ name, price, quantity });
  }
 
  checkout(): { subtotal: number; discount: number; total: number; strategy: string } {
    const subtotal = this.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
    const total = this.pricingStrategy.calculate(subtotal);
    return {
      subtotal,
      discount: subtotal - total,
      total,
      strategy: this.pricingStrategy.name,
    };
  }
}
 
// --- 使用例: 実行時に戦略を切り替え ---
const cart = new ShoppingCart();
cart.addItem("TypeScript Book", 3000);
cart.addItem("Design Patterns Book", 4000);
 
console.log(cart.checkout());
// { subtotal: 7000, discount: 0, total: 7000, strategy: "regular" }
 
cart.setPricingStrategy(new StudentPricing());
// "Pricing changed to: 学生価格（30%OFF）"
 
console.log(cart.checkout());
// { subtotal: 7000, discount: 2100, total: 4900, strategy: "student" }
 
cart.setPricingStrategy(new PremiumPricing());
console.log(cart.checkout());
// { subtotal: 7000, discount: 700, total: 6300, strategy: "premium" }

// functional-strategy.ts — クラスを使わず関数で Strategy を実現
interface User {
  name: string;
  age: number;
  email: string;
  createdAt: Date;
  score: number;
}
 
// Strategy を関数型で定義
type SortStrategy<T> = (a: T, b: T) => number;
 
const byName: SortStrategy<User> = (a, b) =>
  a.name.localeCompare(b.name);
 
const byAge: SortStrategy<User> = (a, b) =>
  a.age - b.age;
 
const byCreatedDesc: SortStrategy<User> = (a, b) =>
  b.createdAt.getTime() - a.createdAt.getTime();
 
const byScore: SortStrategy<User> = (a, b) =>
  b.score - a.score;
 
// 合成: 複数のソート条件を組み合わせる
function composeStrategies<T>(...strategies: SortStrategy<T>[]): SortStrategy<T> {
  return (a, b) => {
    for (const strategy of strategies) {
      const result = strategy(a, b);
      if (result !== 0) return result;
    }
    return 0;
  };
}
 
// 反転: 降順にする
function reverse<T>(strategy: SortStrategy<T>): SortStrategy<T> {
  return (a, b) => -strategy(a, b);
}
 
// Context 関数
function sortUsers(users: User[], strategy: SortStrategy<User>): User[] {
  return [...users].sort(strategy);
}
 
// --- 使用例 ---
const users: User[] = [
  { name: "Charlie", age: 30, email: "c@test.com", createdAt: new Date("2024-01"), score: 85 },
  { name: "Alice", age: 25, email: "a@test.com", createdAt: new Date("2024-03"), score: 92 },
  { name: "Bob", age: 30, email: "b@test.com", createdAt: new Date("2024-02"), score: 88 },
];
 
// 単一ソート
console.log(sortUsers(users, byName).map(u => u.name));
// ["Alice", "Bob", "Charlie"]
 
console.log(sortUsers(users, byScore).map(u => u.name));
// ["Alice", "Bob", "Charlie"]
 
// 合成ソート: 年齢順 -> 名前順（同じ年齢の場合）
const byAgeThenName = composeStrategies(byAge, byName);
console.log(sortUsers(users, byAgeThenName).map(u => u.name));
// ["Alice", "Bob", "Charlie"]
 
// 反転: 名前の逆順
console.log(sortUsers(users, reverse(byName)).map(u => u.name));
// ["Charlie", "Bob", "Alice"]

// validation-strategy.ts — フォームバリデーション
interface ValidationResult {
  valid: boolean;
  errors: string[];
}
 
interface ValidationStrategy {
  validate(value: string): ValidationResult;
  readonly fieldName: string;
}
 
class EmailValidation implements ValidationStrategy {
  readonly fieldName = "email";
 
  validate(value: string): ValidationResult {
    const errors: string[] = [];
    if (!value) errors.push("Email is required");
    else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
      errors.push("Invalid email format");
    }
    return { valid: errors.length === 0, errors };
  }
}
 
class PasswordValidation implements ValidationStrategy {
  readonly fieldName = "password";
 
  constructor(
    private options: {
      minLength?: number;
      requireUppercase?: boolean;
      requireDigit?: boolean;
      requireSpecial?: boolean;
    } = {}
  ) {}
 
  validate(value: string): ValidationResult {
    const errors: string[] = [];
    const { minLength = 8, requireUppercase = true, requireDigit = true, requireSpecial = false } = this.options;
 
    if (value.length < minLength) errors.push(`Minimum ${minLength} characters`);
    if (requireUppercase && !/[A-Z]/.test(value)) errors.push("Need uppercase letter");
    if (requireDigit && !/[0-9]/.test(value)) errors.push("Need digit");
    if (requireSpecial && !/[!@#$%^&*]/.test(value)) errors.push("Need special character");
 
    return { valid: errors.length === 0, errors };
  }
}
 
class PhoneValidation implements ValidationStrategy {
  readonly fieldName = "phone";
 
  constructor(private country: 'JP' | 'US' = 'JP') {}
 
  validate(value: string): ValidationResult {
    const errors: string[] = [];
    const patterns = {
      JP: /^0\d{1,4}-?\d{1,4}-?\d{4}$/,
      US: /^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/,
    };
 
    if (!value) errors.push("Phone number is required");
    else if (!patterns[this.country].test(value)) {
      errors.push(`Invalid ${this.country} phone number format`);
    }
 
    return { valid: errors.length === 0, errors };
  }
}
 
// Context: フォームフィールド
class FormField {
  private strategies: ValidationStrategy[] = [];
 
  constructor(
    private name: string,
    ...strategies: ValidationStrategy[]
  ) {
    this.strategies = strategies;
  }
 
  validate(value: string): ValidationResult {
    const allErrors: string[] = [];
    for (const strategy of this.strategies) {
      const result = strategy.validate(value);
      allErrors.push(...result.errors);
    }
    return { valid: allErrors.length === 0, errors: allErrors };
  }
}
 
// --- 使用例 ---
const emailField = new FormField("email", new EmailValidation());
console.log(emailField.validate("test@example.com"));
// { valid: true, errors: [] }
 
console.log(emailField.validate("invalid-email"));
// { valid: false, errors: ["Invalid email format"] }
 
const passwordField = new FormField(
  "password",
  new PasswordValidation({ minLength: 10, requireSpecial: true })
);
console.log(passwordField.validate("short"));
// { valid: false, errors: ["Minimum 10 characters", "Need uppercase letter", "Need digit", "Need special character"] }
 
console.log(passwordField.validate("MyP@ssw0rd!!"));
// { valid: true, errors: [] }

# compression_strategy.py — Python Protocol による Strategy
from typing import Protocol
import gzip
import time
 
 
class CompressionStrategy(Protocol):
    """圧縮戦略のプロトコル（インタフェース）"""
    @property
    def name(self) -> str: ...
    def compress(self, data: bytes) -> bytes: ...
    def decompress(self, data: bytes) -> bytes: ...
 
 
class GzipCompression:
    name = "gzip"
 
    def compress(self, data: bytes) -> bytes:
        return gzip.compress(data)
 
    def decompress(self, data: bytes) -> bytes:
        return gzip.decompress(data)
 
 
class NoCompression:
    name = "none"
 
    def compress(self, data: bytes) -> bytes:
        return data
 
    def decompress(self, data: bytes) -> bytes:
        return data
 
 
class FileProcessor:
    """Context: ファイル処理器"""
    def __init__(self, compression: CompressionStrategy):
        self._compression = compression
 
    def set_compression(self, compression: CompressionStrategy) -> None:
        self._compression = compression
        print(f"Compression changed to: {compression.name}")
 
    def save(self, data: bytes, path: str) -> dict:
        start = time.time()
        compressed = self._compression.compress(data)
        elapsed = time.time() - start
 
        with open(path, "wb") as f:
            f.write(compressed)
 
        ratio = len(compressed) / len(data) * 100
        return {
            "original_size": len(data),
            "compressed_size": len(compressed),
            "ratio": f"{ratio:.1f}%",
            "time_ms": f"{elapsed * 1000:.2f}",
            "algorithm": self._compression.name,
        }
 
    def load(self, path: str) -> bytes:
        with open(path, "rb") as f:
            compressed = f.read()
        return self._compression.decompress(compressed)
 
 
# --- 使用例 ---
data = b"Hello " * 1000  # 6000 bytes の繰り返しデータ
 
processor = FileProcessor(GzipCompression())
result = processor.save(data, "/tmp/data.gz")
print(result)
# {"original_size": 6000, "compressed_size": ~40, "ratio": "0.7%", ...}
 
processor.set_compression(NoCompression())
result = processor.save(data, "/tmp/data.raw")
print(result)
# {"original_size": 6000, "compressed_size": 6000, "ratio": "100.0%", ...}

// strategy-registry.ts — Registry + Strategy
class StrategyRegistry<T> {
  private strategies = new Map<string, T>();
  private defaultKey: string | null = null;
 
  register(name: string, strategy: T, isDefault: boolean = false): this {
    this.strategies.set(name, strategy);
    if (isDefault) this.defaultKey = name;
    return this;
  }
 
  get(name: string): T {
    const strategy = this.strategies.get(name);
    if (strategy) return strategy;
 
    // デフォルト戦略があれば返す
    if (this.defaultKey) {
      return this.strategies.get(this.defaultKey)!;
    }
 
    throw new Error(`Strategy "${name}" not found. Available: ${this.getAvailableNames().join(', ')}`);
  }
 
  has(name: string): boolean {
    return this.strategies.has(name);
  }
 
  getAvailableNames(): string[] {
    return [...this.strategies.keys()];
  }
}
 
// --- 料金計算の Registry ---
const pricingRegistry = new StrategyRegistry<PricingStrategy>();
pricingRegistry
  .register("regular", new RegularPricing(), true) // デフォルト
  .register("premium", new PremiumPricing())
  .register("student", new StudentPricing())
  .register("senior", new SeniorPricing());
 
// APIリクエストから動的に選択
function handleCheckout(req: { membershipType: string; items: any[] }) {
  const strategy = pricingRegistry.get(req.membershipType);
  const cart = new ShoppingCart(strategy);
  // ...
}
 
// 利用可能な戦略の一覧
console.log(pricingRegistry.getAvailableNames());
// ["regular", "premium", "student", "senior"]

// retry-strategy.ts — リトライアルゴリズムの Strategy
interface RetryStrategy {
  readonly name: string;
  getDelay(attempt: number, baseDelay: number): number;
  shouldRetry(attempt: number, maxAttempts: number, error: Error): boolean;
}
 
class LinearRetry implements RetryStrategy {
  readonly name = "linear";
  getDelay(attempt: number, baseDelay: number): number {
    return baseDelay * attempt;
  }
  shouldRetry(attempt: number, maxAttempts: number): boolean {
    return attempt < maxAttempts;
  }
}
 
class ExponentialBackoff implements RetryStrategy {
  readonly name = "exponential";
  getDelay(attempt: number, baseDelay: number): number {
    return baseDelay * Math.pow(2, attempt - 1);
  }
  shouldRetry(attempt: number, maxAttempts: number): boolean {
    return attempt < maxAttempts;
  }
}
 
class ExponentialWithJitter implements RetryStrategy {
  readonly name = "exponential-jitter";
  getDelay(attempt: number, baseDelay: number): number {
    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
    const jitter = Math.random() * exponentialDelay;
    return Math.floor(jitter);
  }
  shouldRetry(attempt: number, maxAttempts: number, error: Error): boolean {
    // 4xx エラーはリトライしない（クライアントエラー）
    if ('statusCode' in error && (error as any).statusCode >= 400 && (error as any).statusCode < 500) {
      return false;
    }
    return attempt < maxAttempts;
  }
}
 
// Context: HTTP クライアント
class ResilientHttpClient {
  constructor(
    private retryStrategy: RetryStrategy,
    private maxAttempts: number = 3,
    private baseDelay: number = 1000
  ) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    let lastError: Error | null = null;
 
    for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
      try {
        const response = await fetch(url, options);
        if (response.ok) return response;
        throw Object.assign(new Error(`HTTP ${response.status}`), { statusCode: response.status });
      } catch (error) {
        lastError = error as Error;
        console.log(`[${this.retryStrategy.name}] Attempt ${attempt} failed: ${lastError.message}`);
 
        if (!this.retryStrategy.shouldRetry(attempt, this.maxAttempts, lastError)) {
          break;
        }
 
        const delay = this.retryStrategy.getDelay(attempt, this.baseDelay);
        console.log(`Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
 
    throw lastError;
  }
}
 
// --- 使用例 ---
// 開発環境: リニアリトライ（予測しやすい）
const devClient = new ResilientHttpClient(new LinearRetry(), 3, 500);
 
// 本番環境: 指数バックオフ + ジッター（サーバー負荷分散）
const prodClient = new ResilientHttpClient(new ExponentialWithJitter(), 5, 1000);

// logging-strategy.ts — ログ出力先の Strategy
interface LogEntry {
  level: 'debug' | 'info' | 'warn' | 'error';
  message: string;
  timestamp: Date;
  context?: Record<string, unknown>;
}
 
interface LoggingStrategy {
  log(entry: LogEntry): void;
  flush?(): Promise<void>;
}
 
class ConsoleLogging implements LoggingStrategy {
  log(entry: LogEntry): void {
    const prefix = `[${entry.timestamp.toISOString()}] [${entry.level.toUpperCase()}]`;
    const ctx = entry.context ? ` ${JSON.stringify(entry.context)}` : '';
    console.log(`${prefix} ${entry.message}${ctx}`);
  }
}
 
class JsonFileLogging implements LoggingStrategy {
  private buffer: string[] = [];
 
  constructor(private filePath: string, private bufferSize: number = 10) {}
 
  log(entry: LogEntry): void {
    this.buffer.push(JSON.stringify(entry));
    if (this.buffer.length >= this.bufferSize) {
      this.flush();
    }
  }
 
  async flush(): Promise<void> {
    if (this.buffer.length === 0) return;
    const data = this.buffer.join('\n') + '\n';
    this.buffer = [];
    console.log(`[JsonFileLogging] Flushed ${data.split('\n').length - 1} entries to ${this.filePath}`);
  }
}
 
class MultiLogging implements LoggingStrategy {
  constructor(private strategies: LoggingStrategy[]) {}
 
  log(entry: LogEntry): void {
    this.strategies.forEach(s => s.log(entry));
  }
 
  async flush(): Promise<void> {
    await Promise.all(
      this.strategies
        .filter(s => s.flush)
        .map(s => s.flush!())
    );
  }
}
 
// Context: Logger
class Logger {
  constructor(private strategy: LoggingStrategy) {}
 
  setStrategy(strategy: LoggingStrategy): void {
    this.strategy = strategy;
  }
 
  private createEntry(level: LogEntry['level'], message: string, context?: Record<string, unknown>): LogEntry {
    return { level, message, timestamp: new Date(), context };
  }
 
  debug(message: string, context?: Record<string, unknown>): void {
    this.strategy.log(this.createEntry('debug', message, context));
  }
 
  info(message: string, context?: Record<string, unknown>): void {
    this.strategy.log(this.createEntry('info', message, context));
  }
 
  warn(message: string, context?: Record<string, unknown>): void {
    this.strategy.log(this.createEntry('warn', message, context));
  }
 
  error(message: string, context?: Record<string, unknown>): void {
    this.strategy.log(this.createEntry('error', message, context));
  }
}
 
// --- 使用例 ---
// 開発環境: コンソールのみ
const devLogger = new Logger(new ConsoleLogging());
devLogger.info("Server started", { port: 3000 });
 
// 本番環境: コンソール + JSON ファイル
const prodLogger = new Logger(new MultiLogging([
  new ConsoleLogging(),
  new JsonFileLogging("/var/log/app.jsonl"),
]));
prodLogger.error("Database connection failed", { host: "db.example.com" });

// NG: 過剰設計（YAGNI 違反）
interface GreetingStrategy {
  greet(name: string): string;
}
class FormalGreeting implements GreetingStrategy {
  greet(name: string) { return `Dear ${name}`; }
}
class CasualGreeting implements GreetingStrategy {
  greet(name: string) { return `Hi ${name}`; }
}
 
// このためだけにインタフェース + 2クラスは過剰
// 三項演算子で十分:
 
// OK: シンプルに書く
const greet = (name: string, formal: boolean) =>
  formal ? `Dear ${name}` : `Hi ${name}`;

// NG: Context が Strategy の具象型をチェック
class Context {
  execute(): void {
    if (this.strategy instanceof StrategyA) {
      // StrategyA 固有の前処理
      this.prepareForA();
    }
    if (this.strategy instanceof StrategyB) {
      // StrategyB 固有の前処理
      this.prepareForB();
    }
    this.strategy.execute();
  }
}
// 問題: Strategy を追加するたびに Context も変更が必要 -> OCP 違反
 
// OK: Context は Strategy インタフェースのみに依存
class Context {
  execute(): void {
    // 前処理は Strategy 内部に閉じ込める
    this.strategy.execute();
  }
}
 
// Strategy 側で前処理を含める
class StrategyA implements Strategy {
  execute(): void {
    this.prepare(); // 固有の前処理
    this.doWork();  // 本処理
  }
}

// NG: 1つの Strategy に複数の無関係な責務
interface AllInOneStrategy {
  calculatePrice(price: number): number;
  formatOutput(data: any): string;
  validateInput(input: string): boolean;
  sendNotification(message: string): void;
}
// 問題: 料金計算を変えたいだけなのに、全てのメソッドを実装する必要がある
 
// OK: 責務ごとに Strategy を分割
interface PricingStrategy {
  calculate(price: number): number;
}
 
interface FormattingStrategy {
  format(data: any): string;
}
 
interface ValidationStrategy {
  validate(input: string): ValidationResult;
}
 
// Context は必要な Strategy だけを使う
class OrderService {
  constructor(
    private pricing: PricingStrategy,
    private formatting: FormattingStrategy,
  ) {}
}

// NG: マルチスレッド環境で Strategy の切り替えが競合する
class PaymentProcessor {
  private strategy: PaymentStrategy;
 
  setStrategy(strategy: PaymentStrategy): void {
    this.strategy = strategy; // スレッドAが書き換え中にスレッドBが読む可能性
  }
 
  process(order: Order): PaymentResult {
    return this.strategy.process(order); // どのStrategyが使われるか不定
  }
}
 
// OK: Strategy を引数で渡すか、イミュータブルなContextを使う
class PaymentProcessor {
  // 方法1: Strategyを引数として受け取る（状態を持たない）
  process(order: Order, strategy: PaymentStrategy): PaymentResult {
    return strategy.process(order);
  }
}
 
// 方法2: イミュータブルなContext（Strategyの変更時は新インスタンスを生成）
class PaymentProcessor {
  constructor(private readonly strategy: PaymentStrategy) {}
 
  withStrategy(strategy: PaymentStrategy): PaymentProcessor {
    return new PaymentProcessor(strategy);
  }
 
  process(order: Order): PaymentResult {
    return this.strategy.process(order);
  }
}

const processor = new TextProcessor(new UpperCase());
console.log(processor.process("hello world")); // "HELLO WORLD"
 
processor.setStrategy(new CamelCase());
console.log(processor.process("hello world")); // "helloWorld"
 
processor.setStrategy(new SnakeCase());
console.log(processor.process("hello world")); // "hello_world"
 
processor.setStrategy(new KebabCase());
console.log(processor.process("hello world")); // "hello-world"

const registry = new StrategyRegistry<ShippingStrategy>();
registry
  .register("standard", new StandardShipping(), true)
  .register("express", new ExpressShipping())
  .register("same-day", new SameDayShipping());
 
console.log(registry.getAvailableNames());
// ["standard", "express", "same-day"]
 
const strategy = registry.get("express");
console.log(strategy.calculate(1000, 2.5)); // 送料計算
 
// 未登録の名前 -> デフォルト戦略
const fallback = registry.get("unknown");
console.log(fallback === registry.get("standard")); // true

interface ImageData {
  width: number;
  height: number;
  format: string;
  quality: number;
}
 
const pipeline = new TransformPipeline<ImageData>()
  .addStep(new ResizeStrategy(800, 600))
  .addConditional(
    img => img.format === 'png',
    new ConvertToJpeg()
  )
  .addStep(new CompressStrategy(85));
 
const result = pipeline.execute({
  width: 1920, height: 1080, format: 'png', quality: 100
});
console.log(result);
// { width: 800, height: 600, format: 'jpg', quality: 85 }

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]

// 1. Strategy の単体テスト
describe('ExpressShipping', () => {
  it('5kg以下の荷物に速達料金を適用する', () => {
    const strategy = new ExpressShipping();
    expect(strategy.calculate(1000, 3.0)).toBe(1800); // 基本料 + 速達加算
  });
});
 
// 2. Context のテスト（モック使用）
describe('ShippingCalculator', () => {
  it('設定された Strategy に計算を委譲する', () => {
    const mockStrategy: ShippingStrategy = {
      calculate: jest.fn().mockReturnValue(500),
    };
    const calculator = new ShippingCalculator(mockStrategy);
    const result = calculator.calculateShipping(1000, 2.0);
    expect(mockStrategy.calculate).toHaveBeenCalledWith(1000, 2.0);
    expect(result).toBe(500);
  });
});
 
// 3. 統合テスト
describe('ShippingCalculator + StandardShipping', () => {
  it('実際の送料計算が正しい', () => {
    const calculator = new ShippingCalculator(new StandardShipping());
    expect(calculator.calculateShipping(1000, 2.0)).toBe(600);
  });
});