// SOLID違反を示す典型的なコードスメル
 
// 1. 巨大クラス（God Object） → SRP違反
class ApplicationManager {
  // 500行以上のメソッドが複数...
  handleUserRegistration() { /* ... */ }
  processPayment() { /* ... */ }
  generateReport() { /* ... */ }
  sendNotification() { /* ... */ }
  manageInventory() { /* ... */ }
  // → 変更理由が5つ以上
}
 
// 2. switch/if-else の連鎖 → OCP違反
function processShape(shape: any): string {
  switch (shape.type) {
    case "circle": return `Circle: ${Math.PI * shape.r ** 2}`;
    case "rect": return `Rect: ${shape.w * shape.h}`;
    case "triangle": return `Triangle: ${0.5 * shape.b * shape.h}`;
    // 新しい図形を追加するたびにここを修正...
    default: throw new Error("Unknown shape");
  }
}
 
// 3. instanceof チェック → LSP違反の疑い
function fly(bird: Bird): void {
  if (bird instanceof Penguin) {
    throw new Error("Penguins can't fly!");
    // → Penguin は Bird の契約を満たしていない
  }
  bird.fly();
}
 
// 4. 空実装メソッド → ISP違反
class RobotWorker implements Worker {
  work(): void { /* 実装あり */ }
  eat(): void { /* 空実装 - ロボットは食べない */ }
  sleep(): void { /* 空実装 - ロボットは寝ない */ }
}
 
// 5. new による具象クラスの直接生成 → DIP違反
class OrderService {
  private repository = new MySQLOrderRepository();
  private mailer = new SmtpMailer();
  private logger = new FileLogger();
  // → テスト時にモック差し替えが不可能
}

// ===== BEFORE: SOLID違反だらけのECサイト注文処理 =====
 
class OrderProcessor {
  processOrder(order: any): void {
    // バリデーション（SRP違反: バリデーションロジックが混在）
    if (!order.items || order.items.length === 0) {
      throw new Error("No items");
    }
    if (!order.paymentMethod) {
      throw new Error("No payment method");
    }
 
    // 合計計算
    let total = 0;
    for (const item of order.items) {
      total += item.price * item.quantity;
    }
 
    // 割引適用（OCP違反: 新しい割引タイプの追加でここを修正）
    if (order.discountType === "percentage") {
      total *= (1 - order.discountValue / 100);
    } else if (order.discountType === "fixed") {
      total -= order.discountValue;
    } else if (order.discountType === "bogo") {
      // Buy One Get One Free
      const cheapest = Math.min(...order.items.map((i: any) => i.price));
      total -= cheapest;
    }
 
    // 支払い処理（OCP違反: 新しい支払い方法で修正）
    if (order.paymentMethod === "credit") {
      // Stripe API呼び出し
      console.log(`Charging credit card: $${total}`);
    } else if (order.paymentMethod === "paypal") {
      console.log(`PayPal payment: $${total}`);
    } else if (order.paymentMethod === "bank") {
      console.log(`Bank transfer: $${total}`);
    }
 
    // DB保存（DIP違反: 具象に直接依存）
    const mysql = new MySQLConnection();
    mysql.query(`INSERT INTO orders VALUES (${total})`);
 
    // メール送信
    const smtp = new SmtpClient();
    smtp.send(order.email, "Order Confirmation", `Total: $${total}`);
 
    // ログ
    const fs = require("fs");
    fs.appendFileSync("orders.log", `Order processed: $${total}\n`);
  }
}

// ===== AFTER: SOLID原則を適用したリファクタリング =====
 
// --- S: 単一責任 - 各クラスが1つの責任のみ ---
 
interface OrderItem {
  name: string;
  price: number;
  quantity: number;
}
 
interface Order {
  id: string;
  items: OrderItem[];
  customerEmail: string;
  discountCode?: string;
}
 
// バリデーション責任
class OrderValidator {
  validate(order: Order): void {
    if (!order.items || order.items.length === 0) {
      throw new ValidationError("Order must have at least one item");
    }
    for (const item of order.items) {
      if (item.price <= 0) throw new ValidationError("Invalid price");
      if (item.quantity <= 0) throw new ValidationError("Invalid quantity");
    }
  }
}
 
// 合計計算責任
class OrderCalculator {
  calculateSubtotal(items: OrderItem[]): number {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  }
}
 
// --- O: 開放閉鎖 - 割引と支払いを拡張可能に ---
 
interface DiscountStrategy {
  apply(total: number, order: Order): number;
}
 
class PercentageDiscount implements DiscountStrategy {
  constructor(private percentage: number) {}
  apply(total: number): number {
    return total * (1 - this.percentage / 100);
  }
}
 
class FixedDiscount implements DiscountStrategy {
  constructor(private amount: number) {}
  apply(total: number): number {
    return Math.max(0, total - this.amount);
  }
}
 
class BuyOneGetOneFreeDiscount implements DiscountStrategy {
  apply(total: number, order: Order): number {
    const cheapest = Math.min(...order.items.map(i => i.price));
    return total - cheapest;
  }
}
// 新しい割引タイプ → クラスを追加するだけ。既存コード変更不要
 
// --- D: 依存性逆転 - 抽象に依存 ---
 
interface PaymentGateway {
  charge(amount: number, orderId: string): Promise<PaymentResult>;
}
 
interface OrderRepository {
  save(order: Order, total: number): Promise<void>;
}
 
interface NotificationService {
  notifyOrderConfirmation(email: string, order: Order, total: number): Promise<void>;
}
 
interface Logger {
  info(message: string): void;
  error(message: string, error: Error): void;
}
 
// 具象実装（交換可能）
class StripePaymentGateway implements PaymentGateway {
  async charge(amount: number, orderId: string): Promise<PaymentResult> {
    // Stripe API 呼び出し
    return { success: true, transactionId: `stripe_${orderId}` };
  }
}
 
class PostgresOrderRepository implements OrderRepository {
  async save(order: Order, total: number): Promise<void> {
    // PostgreSQL に保存
  }
}
 
class EmailNotificationService implements NotificationService {
  async notifyOrderConfirmation(
    email: string, order: Order, total: number
  ): Promise<void> {
    // SMTP 送信
  }
}
 
// --- オーケストレーター（薄い調整役） ---
 
class OrderProcessor {
  constructor(
    private validator: OrderValidator,
    private calculator: OrderCalculator,
    private discount: DiscountStrategy,
    private payment: PaymentGateway,
    private repository: OrderRepository,
    private notification: NotificationService,
    private logger: Logger,
  ) {}
 
  async processOrder(order: Order): Promise<void> {
    this.validator.validate(order);
 
    let total = this.calculator.calculateSubtotal(order.items);
    total = this.discount.apply(total, order);
 
    const result = await this.payment.charge(total, order.id);
    if (!result.success) {
      throw new PaymentError("Payment failed");
    }
 
    await this.repository.save(order, total);
    await this.notification.notifyOrderConfirmation(
      order.customerEmail, order, total
    );
    this.logger.info(`Order ${order.id} processed: $${total}`);
  }
}

// === S: 単一責任 ===
// ❌ 複数の責任
class User {
  save() { /* DB保存 */ }
  sendEmail() { /* メール送信 */ }
  generateReport() { /* レポート生成 */ }
}
 
// ✅ 単一の責任
class User { /* ユーザーデータのみ */ }
class UserRepository { save(user: User) { } }
class EmailService { send(to: string, body: string) { } }
class ReportGenerator { generate(user: User) { } }

# Python: SRP の実践例
 
# ❌ SRP違反: レポート生成クラスが複数の責任を持つ
class ReportManager:
    def fetch_data(self) -> list:
        """DBからデータ取得"""
        connection = psycopg2.connect("dbname=mydb")
        cursor = connection.cursor()
        cursor.execute("SELECT * FROM sales")
        return cursor.fetchall()
 
    def calculate_statistics(self, data: list) -> dict:
        """統計計算"""
        total = sum(row[1] for row in data)
        average = total / len(data)
        return {"total": total, "average": average}
 
    def format_as_html(self, stats: dict) -> str:
        """HTML形式にフォーマット"""
        return f"<h1>Report</h1><p>Total: {stats['total']}</p>"
 
    def send_email(self, html: str, recipient: str) -> None:
        """メール送信"""
        import smtplib
        server = smtplib.SMTP("localhost")
        server.sendmail("noreply@example.com", recipient, html)
 
# ✅ SRP適用: 各クラスが1つの責任
class SalesDataFetcher:
    """データ取得のみ"""
    def __init__(self, connection_string: str):
        self._conn_str = connection_string
 
    def fetch(self) -> list[dict]:
        connection = psycopg2.connect(self._conn_str)
        cursor = connection.cursor()
        cursor.execute("SELECT * FROM sales")
        return [{"date": row[0], "amount": row[1]} for row in cursor.fetchall()]
 
 
class StatisticsCalculator:
    """統計計算のみ"""
    def calculate(self, data: list[dict]) -> dict:
        amounts = [d["amount"] for d in data]
        return {
            "total": sum(amounts),
            "average": sum(amounts) / len(amounts),
            "max": max(amounts),
            "min": min(amounts),
        }
 
 
class HtmlReportFormatter:
    """HTMLフォーマットのみ"""
    def format(self, stats: dict) -> str:
        return f"<h1>Sales Report</h1><p>Total: {stats['total']}</p>"
 
 
class EmailSender:
    """メール送信のみ"""
    def __init__(self, smtp_host: str):
        self._host = smtp_host
 
    def send(self, to: str, subject: str, body: str) -> None:
        server = smtplib.SMTP(self._host)
        server.sendmail("noreply@example.com", to, body)
 
 
class SalesReportUseCase:
    """オーケストレーション（薄い調整役）"""
    def __init__(
        self,
        fetcher: SalesDataFetcher,
        calculator: StatisticsCalculator,
        formatter: HtmlReportFormatter,
        sender: EmailSender,
    ):
        self._fetcher = fetcher
        self._calculator = calculator
        self._formatter = formatter
        self._sender = sender
 
    def execute(self, recipient: str) -> None:
        data = self._fetcher.fetch()
        stats = self._calculator.calculate(data)
        html = self._formatter.format(stats)
        self._sender.send(recipient, "Sales Report", html)

// Java: SRP の実践例
 
// ❌ SRP違反
public class Employee {
    private String name;
    private double salary;
 
    // 責任1: 給与計算（経理部門が管理）
    public double calculatePay() {
        return salary * getOvertimeRate();
    }
 
    // 責任2: 労働時間レポート（人事部門が管理）
    public String reportHours() {
        return String.format("%s: %d hours", name, getHoursWorked());
    }
 
    // 責任3: DB永続化（技術部門が管理）
    public void save() {
        String sql = "UPDATE employees SET salary = ? WHERE name = ?";
        // JDBC処理...
    }
 
    // 共通メソッド（危険: 経理の変更が人事に影響する可能性）
    private int getHoursWorked() {
        // 経理と人事で「労働時間」の定義が異なる可能性
        return 160;
    }
}
 
// ✅ SRP適用
public record Employee(String id, String name, double salary) {}
 
public class PayCalculator {
    public double calculatePay(Employee employee) {
        return employee.salary() * getOvertimeRate();
    }
}
 
public class HoursReporter {
    public String reportHours(Employee employee) {
        return String.format("%s: %d hours", employee.name(), getHoursWorked());
    }
}
 
public class EmployeeRepository {
    public void save(Employee employee) {
        // JPA/Hibernate で永続化
    }
}

// === O: 開放閉鎖 ===
// ❌ 新しい形状を追加するたびに修正が必要
function calculateArea(shape: any): number {
  if (shape.type === "circle") return Math.PI * shape.radius ** 2;
  if (shape.type === "rectangle") return shape.width * shape.height;
  // 新しい形状を追加するたびにここを修正...
}
 
// ✅ 新しい形状はクラスを追加するだけ
interface Shape { area(): number; }
class Circle implements Shape { area() { return Math.PI * this.radius ** 2; } }
class Rectangle implements Shape { area() { return this.width * this.height; } }
// Triangle を追加しても既存コードは変更不要

# Python: OCP の実践例 - ファイルエクスポーター
 
from abc import ABC, abstractmethod
import json
import csv
import io
 
# ❌ OCP違反: 新しいフォーマットを追加するたびに修正
class DataExporter:
    def export(self, data: list[dict], format_type: str) -> str:
        if format_type == "json":
            return json.dumps(data, indent=2)
        elif format_type == "csv":
            output = io.StringIO()
            writer = csv.DictWriter(output, fieldnames=data[0].keys())
            writer.writeheader()
            writer.writerows(data)
            return output.getvalue()
        elif format_type == "xml":
            # XML対応を追加するたびにこのクラスを修正...
            pass
        else:
            raise ValueError(f"Unknown format: {format_type}")
 
 
# ✅ OCP適用: 新しいフォーマットはクラスを追加するだけ
class ExportFormatter(ABC):
    @abstractmethod
    def format(self, data: list[dict]) -> str:
        ...
 
    @abstractmethod
    def content_type(self) -> str:
        ...
 
    @abstractmethod
    def file_extension(self) -> str:
        ...
 
 
class JsonFormatter(ExportFormatter):
    def format(self, data: list[dict]) -> str:
        return json.dumps(data, indent=2, ensure_ascii=False)
 
    def content_type(self) -> str:
        return "application/json"
 
    def file_extension(self) -> str:
        return ".json"
 
 
class CsvFormatter(ExportFormatter):
    def format(self, data: list[dict]) -> str:
        output = io.StringIO()
        writer = csv.DictWriter(output, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)
        return output.getvalue()
 
    def content_type(self) -> str:
        return "text/csv"
 
    def file_extension(self) -> str:
        return ".csv"
 
 
class XmlFormatter(ExportFormatter):
    """新規追加 - 既存コードの修正は一切不要"""
    def format(self, data: list[dict]) -> str:
        lines = ['<?xml version="1.0" encoding="UTF-8"?>', "<records>"]
        for record in data:
            lines.append("  <record>")
            for key, value in record.items():
                lines.append(f"    <{key}>{value}</{key}>")
            lines.append("  </record>")
        lines.append("</records>")
        return "\n".join(lines)
 
    def content_type(self) -> str:
        return "application/xml"
 
    def file_extension(self) -> str:
        return ".xml"
 
 
class DataExportService:
    """このクラスは新しいフォーマットが追加されても変更不要"""
    def __init__(self, formatter: ExportFormatter):
        self._formatter = formatter
 
    def export(self, data: list[dict]) -> str:
        return self._formatter.format(data)
 
    def export_to_file(self, data: list[dict], filename: str) -> None:
        content = self._formatter.format(data)
        ext = self._formatter.file_extension()
        with open(f"{filename}{ext}", "w") as f:
            f.write(content)

// Java: OCP の実践例 - 税金計算
 
// ❌ OCP違反
public class TaxCalculator {
    public double calculate(String country, double amount) {
        switch (country) {
            case "JP": return amount * 0.10;  // 日本の消費税
            case "US": return amount * 0.07;  // アメリカの消費税
            case "UK": return amount * 0.20;  // イギリスのVAT
            // 新しい国を追加するたびにここを修正...
            default: throw new IllegalArgumentException("Unknown country");
        }
    }
}
 
// ✅ OCP適用
public interface TaxPolicy {
    double calculateTax(double amount);
    String countryCode();
}
 
public class JapaneseTax implements TaxPolicy {
    @Override public double calculateTax(double amount) {
        return amount * 0.10;  // 消費税10%
    }
    @Override public String countryCode() { return "JP"; }
}
 
public class UnitedStatesTax implements TaxPolicy {
    @Override public double calculateTax(double amount) {
        return amount * 0.07;  // Sales tax
    }
    @Override public String countryCode() { return "US"; }
}
 
public class UnitedKingdomTax implements TaxPolicy {
    @Override public double calculateTax(double amount) {
        return amount * 0.20;  // VAT
    }
    @Override public String countryCode() { return "UK"; }
}
 
// Registry パターンで動的に管理
public class TaxCalculator {
    private final Map<String, TaxPolicy> policies = new HashMap<>();
 
    public void register(TaxPolicy policy) {
        policies.put(policy.countryCode(), policy);
    }
 
    public double calculate(String country, double amount) {
        TaxPolicy policy = policies.get(country);
        if (policy == null) {
            throw new IllegalArgumentException("No tax policy for: " + country);
        }
        return policy.calculateTax(amount);
    }
}
 
// 使用例: 新しい国はクラスを追加してregisterするだけ
// TaxCalculator クラスは一切修正不要

// === L: リスコフ置換 ===
// ❌ 正方形は長方形の代替として使えない
class Rectangle {
  setWidth(w: number) { this.width = w; }
  setHeight(h: number) { this.height = h; }
}
class Square extends Rectangle {
  setWidth(w: number) { this.width = w; this.height = w; } // 親と異なる振る舞い!
}
 
// ✅ 共通インターフェースで抽象化
interface Shape { area(): number; }
class Rectangle implements Shape { /* ... */ }
class Square implements Shape { /* ... */ }

# Python: LSP の詳細例
 
from abc import ABC, abstractmethod
 
# ❌ LSP違反: ReadOnlyFile が File の代替として使えない
class File:
    def __init__(self, path: str):
        self.path = path
 
    def read(self) -> str:
        with open(self.path) as f:
            return f.read()
 
    def write(self, content: str) -> None:
        with open(self.path, "w") as f:
            f.write(content)
 
class ReadOnlyFile(File):
    def write(self, content: str) -> None:
        raise PermissionError("Cannot write to read-only file")
        # → 親クラスの契約「write は書き込む」を破っている
        # → File を期待するコードに ReadOnlyFile を渡すとクラッシュ
 
 
# ✅ LSP適用: 読み取りと書き込みを分離
class Readable(ABC):
    @abstractmethod
    def read(self) -> str: ...
 
class Writable(ABC):
    @abstractmethod
    def write(self, content: str) -> None: ...
 
class ReadOnlyFile(Readable):
    def __init__(self, path: str):
        self._path = path
 
    def read(self) -> str:
        with open(self._path) as f:
            return f.read()
 
class ReadWriteFile(Readable, Writable):
    def __init__(self, path: str):
        self._path = path
 
    def read(self) -> str:
        with open(self._path) as f:
            return f.read()
 
    def write(self, content: str) -> None:
        with open(self._path, "w") as f:
            f.write(content)
 
# これで Readable を期待するコードに両方渡せる
# Writable を期待するコードには ReadWriteFile のみ渡せる

// Java: LSP の実践例 - コレクション
 
// ❌ LSP違反の典型例
public class FixedSizeList<E> extends ArrayList<E> {
    private final int maxSize;
 
    public FixedSizeList(int maxSize) {
        this.maxSize = maxSize;
    }
 
    @Override
    public boolean add(E element) {
        if (size() >= maxSize) {
            throw new IllegalStateException("List is full");
            // → ArrayList の契約「add は常に要素を追加する」に違反
        }
        return super.add(element);
    }
}
 
// ✅ LSP適用: 別のインターフェースで設計
public interface BoundedCollection<E> {
    boolean add(E element);  // 契約: 容量があれば追加、なければ false
    boolean isFull();
    int capacity();
    int size();
}
 
public class BoundedList<E> implements BoundedCollection<E> {
    private final List<E> items = new ArrayList<>();
    private final int maxSize;
 
    public BoundedList(int maxSize) { this.maxSize = maxSize; }
 
    @Override
    public boolean add(E element) {
        if (isFull()) return false;  // 例外ではなく false を返す
        return items.add(element);
    }
 
    @Override public boolean isFull() { return items.size() >= maxSize; }
    @Override public int capacity() { return maxSize; }
    @Override public int size() { return items.size(); }
}

// === I: インターフェース分離 ===
// ❌ 巨大インターフェース
interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
}
// ロボットは eat() と sleep() が不要!
 
// ✅ 細かいインターフェースに分離
interface Workable { work(): void; }
interface Eatable { eat(): void; }
interface Sleepable { sleep(): void; }

// TypeScript: ISP の実践例 - プリンター
 
// ❌ ISP違反: 巨大なマルチ機能インターフェース
interface MultiFunctionDevice {
  print(doc: Document): void;
  scan(doc: Document): Image;
  fax(doc: Document): void;
  staple(doc: Document): void;
  copy(doc: Document): Document;
}
 
// シンプルなプリンターも全メソッドを実装する必要がある
class SimplePrinter implements MultiFunctionDevice {
  print(doc: Document): void { /* 実装あり */ }
  scan(doc: Document): Image { throw new Error("Not supported"); }
  fax(doc: Document): void { throw new Error("Not supported"); }
  staple(doc: Document): void { throw new Error("Not supported"); }
  copy(doc: Document): Document { throw new Error("Not supported"); }
}
 
// ✅ ISP適用: 機能ごとにインターフェースを分離
interface Printer {
  print(doc: Document): void;
}
 
interface Scanner {
  scan(doc: Document): Image;
}
 
interface Faxer {
  fax(doc: Document): void;
}
 
interface Stapler {
  staple(doc: Document): void;
}
 
// シンプルなプリンター: 必要な機能だけ実装
class BasicPrinter implements Printer {
  print(doc: Document): void {
    console.log("Printing document...");
  }
}
 
// 高機能複合機: 複数のインターフェースを実装
class OfficePrinter implements Printer, Scanner, Faxer, Stapler {
  print(doc: Document): void { /* ... */ }
  scan(doc: Document): Image { /* ... */ }
  fax(doc: Document): void { /* ... */ }
  staple(doc: Document): void { /* ... */ }
}
 
// クライアントは必要な機能だけに依存
function printReport(printer: Printer): void {
  // Printer インターフェースだけに依存
  // Scanner や Faxer の知識は不要
  printer.print(report);
}

# Python: ISP の実践例 - 認証プロバイダ
 
from abc import ABC, abstractmethod
from typing import Protocol
 
# ❌ ISP違反: 全プロバイダに不要なメソッドを強制
class AuthProvider(ABC):
    @abstractmethod
    def authenticate(self, username: str, password: str) -> bool: ...
 
    @abstractmethod
    def authorize(self, user_id: str, resource: str) -> bool: ...
 
    @abstractmethod
    def refresh_token(self, token: str) -> str: ...
 
    @abstractmethod
    def revoke_token(self, token: str) -> None: ...
 
    @abstractmethod
    def get_user_info(self, token: str) -> dict: ...
 
    @abstractmethod
    def send_mfa_code(self, user_id: str) -> None: ...
 
    @abstractmethod
    def verify_mfa_code(self, user_id: str, code: str) -> bool: ...
 
 
# ✅ ISP適用: 関心事ごとにプロトコルを分離
class Authenticator(Protocol):
    def authenticate(self, username: str, password: str) -> bool: ...
 
class Authorizer(Protocol):
    def authorize(self, user_id: str, resource: str) -> bool: ...
 
class TokenManager(Protocol):
    def refresh_token(self, token: str) -> str: ...
    def revoke_token(self, token: str) -> None: ...
 
class UserInfoProvider(Protocol):
    def get_user_info(self, token: str) -> dict: ...
 
class MfaProvider(Protocol):
    def send_mfa_code(self, user_id: str) -> None: ...
    def verify_mfa_code(self, user_id: str, code: str) -> bool: ...
 
 
# 基本認証: MFAもトークン管理も不要
class BasicAuthProvider:
    def authenticate(self, username: str, password: str) -> bool:
        # パスワード検証のみ
        return check_password(username, password)
 
    def authorize(self, user_id: str, resource: str) -> bool:
        return check_permission(user_id, resource)
 
 
# OAuth: MFAは不要だがトークン管理は必要
class OAuthProvider:
    def authenticate(self, username: str, password: str) -> bool: ...
    def authorize(self, user_id: str, resource: str) -> bool: ...
    def refresh_token(self, token: str) -> str: ...
    def revoke_token(self, token: str) -> None: ...
    def get_user_info(self, token: str) -> dict: ...
 
 
# クライアントは必要なプロトコルだけに依存
def login(auth: Authenticator, username: str, password: str) -> bool:
    return auth.authenticate(username, password)
 
def check_access(authz: Authorizer, user_id: str, resource: str) -> bool:
    return authz.authorize(user_id, resource)

// === D: 依存性逆転 ===
// ❌ 具象に依存
class OrderService {
  private db = new MySQLDatabase(); // 具象クラスに直接依存
  save(order: Order) { this.db.insert(order); }
}
 
// ✅ 抽象に依存
interface Database { insert(data: any): void; }
class OrderService {
  constructor(private db: Database) {} // インターフェースに依存
  save(order: Order) { this.db.insert(order); }
}

// TypeScript: DIP の実践例 - 通知システム
 
// ❌ DIP違反: 上位モジュールが下位モジュールの具象に依存
class UserRegistrationService {
  // 具象クラスを直接生成 → テスト不可、差し替え不可
  private emailClient = new SendGridClient("api-key-xxx");
  private userRepo = new PostgresUserRepository("postgres://...");
  private logger = new WinstonLogger("./logs/app.log");
 
  async register(data: CreateUserDto): Promise<User> {
    const user = await this.userRepo.save(data);
    await this.emailClient.sendWelcome(user.email);
    this.logger.info(`User registered: ${user.id}`);
    return user;
  }
}
 
// ✅ DIP適用: 上位モジュールも下位モジュールも抽象に依存
 
// 抽象（インターフェース）を定義
interface UserRepository {
  save(data: CreateUserDto): Promise<User>;
  findById(id: string): Promise<User | null>;
}
 
interface EmailClient {
  sendWelcome(to: string): Promise<void>;
  sendPasswordReset(to: string, token: string): Promise<void>;
}
 
interface AppLogger {
  info(message: string): void;
  error(message: string, error?: Error): void;
}
 
// 上位モジュール: 抽象のみに依存
class UserRegistrationService {
  constructor(
    private userRepo: UserRepository,
    private emailClient: EmailClient,
    private logger: AppLogger,
  ) {}
 
  async register(data: CreateUserDto): Promise<User> {
    const user = await this.userRepo.save(data);
    await this.emailClient.sendWelcome(user.email);
    this.logger.info(`User registered: ${user.id}`);
    return user;
  }
}
 
// 下位モジュール: 抽象を実装
class PostgresUserRepository implements UserRepository {
  async save(data: CreateUserDto): Promise<User> { /* Postgres実装 */ }
  async findById(id: string): Promise<User | null> { /* Postgres実装 */ }
}
 
class SendGridEmailClient implements EmailClient {
  async sendWelcome(to: string): Promise<void> { /* SendGrid実装 */ }
  async sendPasswordReset(to: string, token: string): Promise<void> { /* ... */ }
}
 
class WinstonLogger implements AppLogger {
  info(message: string): void { /* Winston実装 */ }
  error(message: string, error?: Error): void { /* Winston実装 */ }
}
 
// テスト用モック
class InMemoryUserRepository implements UserRepository {
  private users: User[] = [];
  async save(data: CreateUserDto): Promise<User> {
    const user = { id: String(this.users.length + 1), ...data };
    this.users.push(user);
    return user;
  }
  async findById(id: string): Promise<User | null> {
    return this.users.find(u => u.id === id) ?? null;
  }
}
 
class MockEmailClient implements EmailClient {
  sentEmails: string[] = [];
  async sendWelcome(to: string): Promise<void> {
    this.sentEmails.push(to);
  }
  async sendPasswordReset(to: string, token: string): Promise<void> {
    this.sentEmails.push(`${to}:${token}`);
  }
}
 
// テスト: モックを注入して外部依存なしにテスト可能
describe("UserRegistrationService", () => {
  it("should register a user and send welcome email", async () => {
    const repo = new InMemoryUserRepository();
    const emailClient = new MockEmailClient();
    const logger = new ConsoleLogger();
 
    const service = new UserRegistrationService(repo, emailClient, logger);
    const user = await service.register({
      name: "Test User",
      email: "test@example.com",
    });
 
    expect(user.name).toBe("Test User");
    expect(emailClient.sentEmails).toContain("test@example.com");
  });
});

# Python: DIP の実践例 - DIコンテナ
 
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import TypeVar, Type
 
# 抽象定義
class CacheStore(ABC):
    @abstractmethod
    def get(self, key: str) -> str | None: ...
 
    @abstractmethod
    def set(self, key: str, value: str, ttl: int = 300) -> None: ...
 
class MessageQueue(ABC):
    @abstractmethod
    def publish(self, topic: str, message: dict) -> None: ...
 
    @abstractmethod
    def subscribe(self, topic: str, handler: callable) -> None: ...
 
# 具象実装
class RedisCache(CacheStore):
    def __init__(self, url: str):
        self._url = url
 
    def get(self, key: str) -> str | None:
        # Redis実装
        pass
 
    def set(self, key: str, value: str, ttl: int = 300) -> None:
        # Redis実装
        pass
 
class InMemoryCache(CacheStore):
    """テスト用 / 開発用"""
    def __init__(self):
        self._store: dict[str, str] = {}
 
    def get(self, key: str) -> str | None:
        return self._store.get(key)
 
    def set(self, key: str, value: str, ttl: int = 300) -> None:
        self._store[key] = value
 
class RabbitMQQueue(MessageQueue):
    def __init__(self, url: str):
        self._url = url
 
    def publish(self, topic: str, message: dict) -> None:
        # RabbitMQ実装
        pass
 
    def subscribe(self, topic: str, handler: callable) -> None:
        # RabbitMQ実装
        pass
 
# シンプルなDIコンテナ
class Container:
    """依存性注入コンテナ"""
    def __init__(self):
        self._bindings: dict[type, callable] = {}
 
    def bind(self, abstract: type, factory: callable) -> None:
        self._bindings[abstract] = factory
 
    def resolve(self, abstract: type):
        factory = self._bindings.get(abstract)
        if factory is None:
            raise ValueError(f"No binding for {abstract}")
        return factory()
 
# 環境に応じた設定
def configure_production(container: Container) -> None:
    container.bind(CacheStore, lambda: RedisCache("redis://prod:6379"))
    container.bind(MessageQueue, lambda: RabbitMQQueue("amqp://prod:5672"))
 
def configure_testing(container: Container) -> None:
    container.bind(CacheStore, lambda: InMemoryCache())
    container.bind(MessageQueue, lambda: InMemoryQueue())
 
# 使用例
container = Container()
configure_production(container)  # 本番環境
# configure_testing(container)  # テスト環境
 
cache: CacheStore = container.resolve(CacheStore)
queue: MessageQueue = container.resolve(MessageQueue)

// Step 1: まずシンプルに書く（SOLID無視でOK）
class TodoApp {
  private todos: Todo[] = [];
 
  addTodo(title: string): void {
    this.todos.push({ id: Date.now(), title, done: false });
  }
 
  completeTodo(id: number): void {
    const todo = this.todos.find(t => t.id === id);
    if (todo) todo.done = true;
  }
 
  getAll(): Todo[] {
    return [...this.todos];
  }
}
// → 小さいうちはこれで十分

// Step 2: 変更が発生 → その部分にSRP適用
// 要件: 「Todo をファイルに保存したい」「通知も送りたい」
 
// SRP: 永続化を分離
interface TodoRepository {
  save(todos: Todo[]): Promise<void>;
  load(): Promise<Todo[]>;
}
 
class FileTodoRepository implements TodoRepository {
  async save(todos: Todo[]): Promise<void> {
    await fs.writeFile("todos.json", JSON.stringify(todos));
  }
  async load(): Promise<Todo[]> {
    const data = await fs.readFile("todos.json", "utf-8");
    return JSON.parse(data);
  }
}
 
class TodoService {
  constructor(private repo: TodoRepository) {} // DIP: 抽象に依存
 
  async addTodo(title: string): Promise<Todo> {
    const todos = await this.repo.load();
    const todo = { id: Date.now(), title, done: false };
    todos.push(todo);
    await this.repo.save(todos);
    return todo;
  }
}

// Step 3: 3回目の変更 → OCP で拡張ポイントを設計
// 要件: 「DB保存もしたい」「S3保存もしたい」
 
// OCP: 新しいストレージはクラスを追加するだけ
class DatabaseTodoRepository implements TodoRepository {
  async save(todos: Todo[]): Promise<void> {
    // PostgreSQL に保存
  }
  async load(): Promise<Todo[]> {
    // PostgreSQL から取得
  }
}
 
class S3TodoRepository implements TodoRepository {
  async save(todos: Todo[]): Promise<void> {
    // AWS S3 に保存
  }
  async load(): Promise<Todo[]> {
    // AWS S3 から取得
  }
}
 
// TodoService は一切変更不要（OCP達成）

// TypeScript: 関数型スタイルでのSOLID
 
// SRP: 純粋関数 = 1つの責任
const calculateTax = (amount: number, rate: number): number =>
  amount * rate;
 
const formatCurrency = (amount: number): string =>
  `$${amount.toFixed(2)}`;
 
// OCP: 高階関数で拡張
type Middleware<T> = (data: T) => T;
 
const applyMiddlewares = <T>(data: T, middlewares: Middleware<T>[]): T =>
  middlewares.reduce((acc, mw) => mw(acc), data);
 
// 新しいミドルウェアを追加するだけで拡張可能
const addTimestamp: Middleware<Request> = (req) => ({
  ...req,
  timestamp: Date.now(),
});
 
const addCorrelationId: Middleware<Request> = (req) => ({
  ...req,
  correlationId: crypto.randomUUID(),
});
 
// DIP: 関数を注入
type Fetcher = (url: string) => Promise<Response>;
type Parser<T> = (data: string) => T;
 
const loadData = async <T>(
  url: string,
  fetch: Fetcher,      // 具象ではなく関数型を注入
  parse: Parser<T>,    // パーサーも注入
): Promise<T> => {
  const response = await fetch(url);
  const text = await response.text();
  return parse(text);
};
 
// テスト時: モック関数を渡す
const mockFetch: Fetcher = async () =>
  new Response('{"name":"test"}');
 
const result = await loadData(
  "https://api.example.com/data",
  mockFetch,
  JSON.parse,
);

# Python: 関数型スタイルでのSOLID
 
from typing import Callable, TypeVar
from functools import reduce
 
T = TypeVar("T")
 
# SRP: 純粋関数
def validate_email(email: str) -> bool:
    return "@" in email and "." in email.split("@")[1]
 
def hash_password(password: str) -> str:
    import hashlib
    return hashlib.sha256(password.encode()).hexdigest()
 
# OCP: 高階関数で振る舞いを拡張
Pipeline = list[Callable[[T], T]]
 
def execute_pipeline(data: T, steps: Pipeline[T]) -> T:
    return reduce(lambda acc, step: step(acc), steps, data)
 
# ステップを追加するだけで拡張
def normalize(text: str) -> str:
    return text.strip().lower()
 
def remove_special_chars(text: str) -> str:
    import re
    return re.sub(r"[^a-z0-9\s]", "", text)
 
def truncate(text: str) -> str:
    return text[:100]
 
# パイプライン実行
result = execute_pipeline(
    "  Hello, World! @#$ ",
    [normalize, remove_special_chars, truncate]
)
# → "hello world  "
 
# DIP: 関数注入
def process_order(
    save: Callable[[dict], None],
    notify: Callable[[str, str], None],
    order: dict,
) -> None:
    save(order)
    notify(order["email"], f"Order {order['id']} confirmed")
 
# 本番
process_order(save=db_save, notify=email_notify, order=order_data)
 
# テスト
calls = []
process_order(
    save=lambda o: calls.append(("save", o)),
    notify=lambda e, m: calls.append(("notify", e, m)),
    order={"id": "1", "email": "test@test.com"},
)
assert len(calls) == 2