ドメイン駆動設計(DDD)を改めて整理する

flowchart LR
  subgraph Sales["販売コンテキスト"]
    S["Order =<br/>カート確定後の購入意思"]
  end
  subgraph Logistics["物流コンテキスト"]
    L["Order =<br/>出荷指示が出ている荷物"]
  end
  N["同じ Order でも意味が違ってよい"]

  S -.-> N
  L -.-> N

  classDef context fill:#eef2ff,stroke:#6366f1,color:#312e81
  classDef note fill:#ffffff,stroke:#94a3b8,color:#334155,stroke-dasharray: 5 5
  class S,L context
  class N note

flowchart LR
  E1["🟧 見積依頼を受けた"] --> E2["🟧 見積を作成した"] --> E3["🟧 見積を送付した"]
  E3 --> C2["🟦 コマンド<br/>見積を承認する"] --> E4["🟧 見積が承認された"] --> E5["🟧 受注した"]
  E3 --> C1["🟦 コマンド<br/>見積をキャンセルする"] --> E6["🟧 キャンセルされた"]
  A1["🟪 集約<br/>見積書"] -.イベントを引き起こす本体.-> E2
  R1["🟨 ルール<br/>承認済みの見積だけが受注に変換できる"] -.制約.-> E5

  classDef event fill:#fdba74,stroke:#ea580c,color:#7c2d12
  classDef command fill:#bfdbfe,stroke:#2563eb,color:#1e3a8a
  classDef aggregate fill:#ddd6fe,stroke:#7c3aed,color:#4c1d95
  classDef rule fill:#fde68a,stroke:#ca8a04,color:#713f12
  class E1,E2,E3,E4,E5,E6 event
  class C1,C2 command
  class A1 aggregate
  class R1 rule

// ❌ ただのstring
const email: string = "user@example.com";

// ✅ Value Object
class Email {
  constructor(private readonly value: string) {
    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
      throw new Error("無効なメールアドレスです");
    }
  }
  equals(other: Email): boolean {
    return this.value === other.value;
  }
  toString(): string {
    return this.value;
  }
}

class User {
  constructor(
    public readonly id: UserId,
    private name: UserName,
    private email: Email,
  ) {}

  changeEmail(newEmail: Email): void {
    this.email = newEmail;
  }

  equals(other: User): boolean {
    return this.id.equals(other.id);
  }
}

// 集約ルート
class Order {
  private items: OrderItem[] = [];

  constructor(
    public readonly id: OrderId,
    private readonly userId: UserId,
  ) {}

  // 集約内部の整合性は集約ルートが守る
  addItem(product: Product, quantity: number): void {
    if (this.items.length >= 100) {
      throw new Error("1注文あたりのアイテム数上限を超えています");
    }
    this.items.push(new OrderItem(product.id, quantity, product.price));
  }

  totalPrice(): Money {
    return this.items.reduce(
      (sum, item) => sum.add(item.subtotal()),
      Money.zero(),
    );
  }
}

// ドメイン層: インターフェースだけを定義
interface OrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  save(order: Order): Promise<void>;
}

// インフラ層: 実装は外側に置く
class PostgresOrderRepository implements OrderRepository {
  async findById(id: OrderId): Promise<Order | null> { /* ... */ }
  async save(order: Order): Promise<void> { /* ... */ }
}

// 「メールアドレスの重複チェック」は User 単体では判断できない
class UserDuplicationChecker {
  constructor(private readonly userRepository: UserRepository) {}

  async exists(email: Email): Promise<boolean> {
    return (await this.userRepository.findByEmail(email)) !== null;
  }
}

flowchart TB
  Start["そのロジックは…"] --> Q1{"単一のオブジェクトの状態を変えるだけ?"}
  Q1 -- YES --> E["Entity のメソッド"]
  Q1 -- NO --> Q2{"複数の集約をまたいで判断する?"}
  Q2 -- YES --> D["Domain Service"]
  Q2 -- NO --> Q3{"リポジトリや外部サービスを必要とする?"}
  Q3 -- YES --> D
  Q3 -- NO --> Q4{"名詞ではなく動詞で表現するのが自然?"}
  Q4 -- YES --> D
  Q4 -- NO --> V["Entity / Value Object"]

  classDef question fill:#eef2ff,stroke:#6366f1,color:#312e81
  classDef answer fill:#ede9fe,stroke:#7c3aed,color:#4c1d95
  class Q1,Q2,Q3,Q4 question
  class E,D,V answer

class Order {
  private status: OrderStatus;
  private items: OrderItem[];

  // ✅ 自分の状態遷移は自分で守る
  cancel(): void {
    if (this.status === OrderStatus.SHIPPED) {
      throw new Error("発送済みの注文はキャンセルできません");
    }
    this.status = OrderStatus.CANCELLED;
  }

  // ✅ 自分のデータから計算するだけのロジック
  totalPrice(): Money {
    return this.items.reduce(
      (sum, item) => sum.add(item.subtotal()),
      Money.zero(),
    );
  }

  // ✅ 自分の不変条件のチェック
  addItem(item: OrderItem): void {
    if (this.items.length >= 100) throw new Error("上限を超えています");
    this.items.push(item);
  }
}

// ✅ 2つの集約をまたぐ「送金」ロジック
class TransferService {
  transfer(from: Account, to: Account, amount: Money): void {
    from.withdraw(amount);
    to.deposit(amount);
    // どちらの口座にも属さない「送金」という概念
  }
}

// ✅ リポジトリが必要な「重複チェック」
class UserDuplicationChecker {
  constructor(private readonly userRepository: UserRepository) {}
  async exists(email: Email): Promise<boolean> {
    return (await this.userRepository.findByEmail(email)) !== null;
  }
}

// ❌ こうなってはいけない
class OrderService {
  cancel(order: Order): void {
    if (order.status === "SHIPPED") throw new Error(/* ... */);
    order.status = "CANCELLED";  // setter で書き換え
  }
  totalPrice(order: Order): Money { /* items を回して合計 */ }
  addItem(order: Order, item: OrderItem): void { /* ... */ }
}
class Order {
  status: string;
  items: OrderItem[];
  // getter / setter のみ ← ドメインモデル貧血症
}

class OrderPlaced {
  constructor(
    public readonly orderId: OrderId,
    public readonly userId: UserId,
    public readonly occurredAt: Date,
  ) {}
}

flowchart TB
  P["Presentation 層<br/>UI / API"]
  A["Application 層<br/>ユースケース"]
  D["Domain 層<br/>モデル・ビジネスルール<br/>ここが主役"]
  I["Infrastructure 層<br/>DB / 外部 API"]

  P --> A --> D
  I --> D

  classDef layer fill:#eef2ff,stroke:#6366f1,color:#312e81
  classDef domain fill:#c7d2fe,stroke:#4338ca,color:#1e1b4b
  class P,A,I layer
  class D domain

// ✅ 良い Controller: 受け流すだけ
@Controller("orders")
class OrderController {
  constructor(private readonly placeOrder: PlaceOrderUseCase) {}

  @Post()
  async create(@Body() body: PlaceOrderRequest): Promise<OrderResponse> {
    // 1. リクエストの形を整える(DTO への変換)
    const command = new PlaceOrderCommand(
      body.userId,
      body.items.map(i => ({ productId: i.productId, quantity: i.quantity })),
    );

    // 2. ユースケースに委譲
    const result = await this.placeOrder.execute(command);

    // 3. レスポンスの形に整えて返す
    return OrderResponse.from(result);
  }
}

// ✅ 良い Application Service: 流れをコーディネートするだけ
class PlaceOrderUseCase {
  constructor(
    private readonly userRepository: UserRepository,
    private readonly productRepository: ProductRepository,
    private readonly orderRepository: OrderRepository,
    private readonly inventoryService: InventoryService,  // Domain Service
    private readonly transactionManager: TransactionManager,
    private readonly eventPublisher: EventPublisher,
  ) {}

  async execute(command: PlaceOrderCommand): Promise<OrderResult> {
    return this.transactionManager.run(async () => {
      // 1. 必要な集約を取得
      const user = await this.userRepository.findById(command.userId);
      if (!user) throw new UserNotFoundError(command.userId);

      const products = await this.productRepository.findByIds(
        command.items.map(i => i.productId),
      );

      // 2. ドメインに処理を委ねる(ビジネスルールは Domain 内)
      const order = Order.place(user, products, command.items);

      // 3. ドメインサービスを呼び出す(複数集約をまたぐ判断)
      await this.inventoryService.reserve(order);

      // 4. 永続化
      await this.orderRepository.save(order);

      // 5. ドメインイベントの発行
      await this.eventPublisher.publishAll(order.pullEvents());

      return OrderResult.from(order);
    });
  }
}

// ❌ アンチパターン: Application 層にビジネスルールが漏れている
class PlaceOrderUseCase {
  async execute(command: PlaceOrderCommand) {
    // ❌ 在庫チェックをここで判定 → ドメイン知識の流出
    if (product.stock < command.quantity) {
      throw new Error("在庫不足");
    }
    // ❌ 合計金額の計算をここで行う → Order の責務
    const total = command.items.reduce((s, i) => s + i.price * i.quantity, 0);
    // ❌ 状態判定をここで行う → Order の責務
    if (user.status === "BLOCKED") throw new Error("利用停止中");

    await this.orderRepository.save({ /* ... */ });
  }
}

sequenceDiagram
  participant Browser
  participant Presentation as Presentation / OrderController
  participant Application as Application / PlaceOrderUseCase
  participant Domain as Domain / Order.place(...)
  participant Infrastructure as Infrastructure / Repository 実装

  Browser->>Presentation: POST /orders
  Presentation->>Application: PlaceOrderCommand を渡す
  Note over Application: トランザクション開始
  Application->>Infrastructure: userRepository.findById()
  Application->>Infrastructure: productRepository.findByIds()
  Infrastructure-->>Application: User / Product 集約
  Application->>Domain: Order.place(user, products, items)
  activate Domain
  Domain->>Domain: ビジネスルール検証
  Domain->>Domain: 不変条件チェック
  Domain->>Domain: OrderPlaced イベント生成
  Domain-->>Application: Order 集約と OrderPlaced
  deactivate Domain
  Application->>Domain: inventoryService.reserve(order)
  Domain-->>Application: 在庫引当結果
  Application->>Infrastructure: orderRepository.save(order)
  Application->>Infrastructure: eventPublisher.publishAll(...)
  Infrastructure-->>Application: 永続化完了
  Note over Application: トランザクションコミット
  Application-->>Presentation: OrderResult
  Presentation-->>Browser: 201 Created

// Domain 層
class Order { /* ビジネスロジックを持つ集約 */ }

// Application 層: 入力 / 出力の DTO
class PlaceOrderCommand { /* リクエスト用 */ }
class OrderResult { /* レスポンス用 */ }

// Presentation 層: HTTP 用の型
class PlaceOrderRequest { /* JSON のスキーマ */ }
class OrderResponse { /* レスポンス JSON */ }

src/
├── controllers/
│   ├── user.controller.ts
│   ├── order.controller.ts
│   └── product.controller.ts
├── services/
│   ├── user.service.ts
│   ├── order.service.ts
│   └── product.service.ts
├── repositories/
│   ├── user.repository.ts
│   ├── order.repository.ts
│   └── product.repository.ts
└── entities/
    ├── user.entity.ts
    ├── order.entity.ts
    └── product.entity.ts

src/
├── contexts/                      ← Bounded Context 単位
│   ├── ordering/                  ← 受注コンテキスト
│   │   ├── domain/
│   │   │   ├── order.ts           (Entity / Aggregate Root)
│   │   │   ├── order-item.ts
│   │   │   ├── order-id.ts        (Value Object)
│   │   │   ├── order-status.ts
│   │   │   ├── order.repository.ts(interface のみ)
│   │   │   └── events/
│   │   │       └── order-placed.ts
│   │   ├── application/
│   │   │   ├── place-order.usecase.ts
│   │   │   └── cancel-order.usecase.ts
│   │   ├── infrastructure/
│   │   │   ├── postgres-order.repository.ts
│   │   │   └── stripe-payment.gateway.ts
│   │   └── presentation/
│   │       ├── order.controller.ts
│   │       └── dto/
│   │           ├── place-order.request.ts
│   │           └── order.response.ts
│   ├── catalog/                   ← 商品カタログコンテキスト
│   │   └── (同じ構造)
│   └── shipping/                  ← 配送コンテキスト
│       └── (同じ構造)
├── shared-kernel/                 ← 全コンテキスト共通の Value Object
│   ├── money.ts
│   ├── email.ts
│   └── user-id.ts
└── shared/                        ← 横断的な技術基盤
    ├── logger.ts
    ├── transaction-manager.ts
    └── event-bus.ts

ordering/domain/
├── order/
│   ├── order.ts                   (集約ルート)
│   ├── order-item.ts
│   ├── order-id.ts
│   ├── order-status.ts
│   ├── order.repository.ts
│   └── events/
│       ├── order-placed.ts
│       └── order-cancelled.ts
├── customer/
│   ├── customer.ts
│   └── customer.repository.ts
└── services/
    └── pricing.service.ts          (Domain Service)

monorepo/
├── apps/
│   ├── web/                       (Next.js のフロントエンド)
│   ├── api/                       (バックエンド API)
│   └── admin/                     (管理画面)
├── packages/
│   ├── ordering-context/          ← パッケージ化された Bounded Context
│   ├── catalog-context/
│   ├── shipping-context/
│   └── shared-kernel/
└── package.json

[フロント特有の関心]
- ルーティング
- 画面ステート(ローディング・エラー・選択中等)
- フォームバリデーション(UX 向け)
- アニメーション
- リアクティブな再描画

flowchart TB
  R["Pages / Routes 層<br/>Next.js の app/, pages/ など"]
  C["Components 層<br/>UI コンポーネント / 見た目の責務"]
  V["ViewModel / Hooks 層<br/>画面状態とユースケース呼出"]
  A["Application 層<br/>ユースケース / API クライアント"]
  D["Domain 層<br/>フロント側の最小限のドメインモデル"]

  R --> C --> V --> A --> D

  classDef layer fill:#eef2ff,stroke:#6366f1,color:#312e81
  classDef domain fill:#c7d2fe,stroke:#4338ca,color:#1e1b4b
  class R,C,V,A layer
  class D domain

// Domain 層: バックエンドと同じドメインルールを薄く持つ
class Order {
  constructor(
    public readonly id: string,
    public readonly status: OrderStatus,
    public readonly items: OrderItem[],
  ) {}

  // UI で「キャンセルボタン押せるか?」の判定はここに集約
  canCancel(): boolean {
    return this.status === "PENDING" || this.status === "CONFIRMED";
  }

  totalPrice(): number {
    return this.items.reduce((s, i) => s + i.price * i.quantity, 0);
  }
}

// Application 層: API を叩くユースケース
class PlaceOrderUseCase {
  constructor(private readonly api: OrderApiClient) {}

  async execute(items: CartItem[]): Promise<Order> {
    const response = await this.api.placeOrder({ items });
    return Order.fromResponse(response);
  }
}

// ViewModel / Hooks 層: 画面状態を管理
function useOrderForm() {
  const [items, setItems] = useState<CartItem[]>([]);
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const placeOrder = useMemo(() => new PlaceOrderUseCase(orderApi), []);

  const submit = async () => {
    setIsSubmitting(true);
    try {
      await placeOrder.execute(items);
    } catch (e) {
      setError(formatError(e));
    } finally {
      setIsSubmitting(false);
    }
  };

  return { items, setItems, isSubmitting, error, submit };
}

// Components 層: 見た目だけに集中
function OrderForm() {
  const { items, isSubmitting, error, submit } = useOrderForm();
  return (
    <form onSubmit={(e) => { e.preventDefault(); submit(); }}>
      {/* JSX */}
    </form>
  );
}

flowchart TB
  Browser["Browser"]
  BFF["BFF<br/>Next.js API Routes / Hono など<br/>画面に最適化したエンドポイント"]
  Ordering["受注サービス"]
  Catalog["カタログサービス"]
  Inventory["在庫サービス"]
  Response["画面向けに整形したレスポンス"]

  Browser --> BFF
  BFF --> Ordering
  BFF --> Catalog
  BFF --> Inventory
  Ordering --> BFF
  Catalog --> BFF
  Inventory --> BFF
  BFF --> Response --> Browser

  classDef layer fill:#eef2ff,stroke:#6366f1,color:#312e81
  classDef service fill:#e0e7ff,stroke:#4f46e5,color:#312e81
  classDef output fill:#ffffff,stroke:#94a3b8,color:#334155
  class Browser,BFF layer
  class Ordering,Catalog,Inventory service
  class Response output

App/
├── Domain/
│   ├── Entities/
│   │   ├── Recipe.swift
│   │   └── Ingredient.swift
│   ├── ValueObjects/
│   │   └── CookingTime.swift
│   ├── Repositories/
│   │   └── RecipeRepository.swift   (protocol / interface)
├── Application/
│   └── UseCases/
│       └── SearchRecipeUseCase.swift
├── Infrastructure/
│   ├── Repositories/
│   │   ├── CoreDataRecipeRepository.swift  (ローカル DB)
│   │   └── ApiRecipeRepository.swift       (リモート API)
│   ├── Storage/
│   │   └── KeyValueStore.swift
│   └── Sync/
│       └── RecipeSyncService.swift
└── Presentation/
    ├── ViewModels/
    │   └── RecipeListViewModel.swift
    └── Views/
        └── RecipeListView.swift            (SwiftUI)

// Domain 層:複数の永続化先を抽象化
protocol RecipeRepository {
    func find(id: RecipeId) async throws -> Recipe?
    func save(_ recipe: Recipe) async throws
}

// Infrastructure 層:ローカル + リモートの合成
class HybridRecipeRepository: RecipeRepository {
    let local: CoreDataRecipeRepository
    let remote: ApiRecipeRepository

    func find(id: RecipeId) async throws -> Recipe? {
        // オフラインでもローカルから取得できる
        if let cached = try await local.find(id: id) {
            return cached
        }
        let remote = try await remote.find(id: id)
        if let recipe = remote {
            try await local.save(recipe)  // キャッシュ更新
        }
        return remote
    }
}

shared/
└── domain/                        ← Web と Mobile で共通
    ├── recipe.ts
    └── recipe.repository.ts
apps/
├── web/
│   └── infrastructure/
│       └── api-recipe.repository.ts
└── mobile/
    └── infrastructure/
        └── sqlite-recipe.repository.ts  (offline first)

// ✅ 設定画面の更新は、これで十分
class UpdateSiteSettingsHandler {
  constructor(private readonly db: Database) {}

  async execute(input: UpdateSiteSettingsInput): Promise<void> {
    await this.db.siteSettings.update({
      where: { id: 1 },
      data: input,
    });
  }
}

src/contexts/
├── ordering/                ← フル DDD
│   ├── domain/
│   ├── application/
│   ├── infrastructure/
│   └── presentation/
├── inventory/               ← フル DDD
│   └── (同上)
├── catalog/                 ← 軽量 DDD(Entity だけは作るが Service は最小)
│   └── (簡略版)
└── admin/                   ← CRUD ベース
    ├── handlers/            (薄いハンドラだけ)
    └── controllers/

// 書き込みは集約経由(厳格)
class CancelOrderUseCase {
  async execute(orderId: OrderId): Promise<void> {
    const order = await this.orderRepository.findById(orderId);
    order.cancel();                    // ドメインルール
    await this.orderRepository.save(order);
  }
}

// 読み取り専用クエリは素の SQL で OK(画面に最適化)
class OrderListQuery {
  async findForAdmin(filter: AdminFilter): Promise<OrderListView[]> {
    return this.db.raw(`
      SELECT o.id, o.status, u.name AS user_name, p.name AS product_name, ...
      FROM orders o
      JOIN users u ON ...
      JOIN order_items oi ON ...
      WHERE ...
    `);
  }
}