オニオンアーキテクチャ入門 ─ 層構造・実装例・他パターンとの違いを体系的に整理

src/
├── domain/                    # Domain Model層 + Domain Service層
│   ├── model/
│   │   ├── Order.ts           # エンティティ
│   │   ├── OrderItem.ts
│   │   └── Money.ts           # 値オブジェクト
│   ├── service/
│   │   └── PricingService.ts  # ドメインサービス
│   └── repository/
│       └── IOrderRepository.ts # リポジトリインターフェース
│
├── application/               # Application Service層
│   ├── usecase/
│   │   ├── CreateOrderUseCase.ts
│   │   └── GetOrderUseCase.ts
│   └── dto/
│       ├── CreateOrderRequest.ts
│       └── OrderResponse.ts
│
├── infrastructure/            # Infrastructure層
│   ├── persistence/
│   │   └── PrismaOrderRepository.ts  # リポジトリ実装
│   ├── web/
│   │   └── OrderController.ts        # HTTPコントローラー
│   └── config/
│       └── container.ts              # DIコンテナ設定
│
└── main.ts                    # エントリーポイント

// domain/model/Money.ts
export class Money {
  private constructor(
    readonly amount: number,
    readonly currency: string
  ) {
    if (amount < 0) throw new Error("金額は0以上である必要があります");
  }

  static of(amount: number, currency: string): Money {
    return new Money(amount, currency);
  }

  add(other: Money): Money {
    if (this.currency !== other.currency) {
      throw new Error("異なる通貨同士は加算できません");
    }
    return Money.of(this.amount + other.amount, this.currency);
  }

  multiply(quantity: number): Money {
    return Money.of(this.amount * quantity, this.currency);
  }
}

// domain/model/Order.ts
import { Money } from "./Money";

export type OrderStatus = "draft" | "confirmed" | "shipped" | "cancelled";

export class Order {
  private constructor(
    readonly id: string,
    readonly customerId: string,
    private _items: OrderItem[],
    private _status: OrderStatus
  ) {}

  static create(id: string, customerId: string): Order {
    return new Order(id, customerId, [], "draft");
  }

  addItem(productId: string, unitPrice: Money, quantity: number): void {
    if (this._status !== "draft") {
      throw new Error("確定済みの注文には商品を追加できません");
    }
    this._items.push({ productId, unitPrice, quantity });
  }

  confirm(): void {
    if (this._items.length === 0) {
      throw new Error("商品が空の注文は確定できません");
    }
    this._status = "confirmed";
  }

  get totalAmount(): Money {
    return this._items.reduce(
      (sum, item) => sum.add(item.unitPrice.multiply(item.quantity)),
      Money.of(0, "JPY")
    );
  }

  get status(): OrderStatus { return this._status; }
  get items(): ReadonlyArray<OrderItem> { return this._items; }
}

interface OrderItem {
  productId: string;
  unitPrice: Money;
  quantity: number;
}

// domain/repository/IOrderRepository.ts
import { Order } from "../model/Order";

export interface IOrderRepository {
  findById(id: string): Promise<Order | null>;
  save(order: Order): Promise<void>;
  nextId(): Promise<string>;
}

// application/usecase/CreateOrderUseCase.ts
import { IOrderRepository } from "../../domain/repository/IOrderRepository";
import { Order } from "../../domain/model/Order";
import { Money } from "../../domain/model/Money";
import { CreateOrderRequest } from "../dto/CreateOrderRequest";
import { OrderResponse } from "../dto/OrderResponse";

export class CreateOrderUseCase {
  constructor(private readonly orderRepo: IOrderRepository) {}

  async execute(request: CreateOrderRequest): Promise<OrderResponse> {
    const orderId = await this.orderRepo.nextId();
    const order = Order.create(orderId, request.customerId);

    for (const item of request.items) {
      order.addItem(
        item.productId,
        Money.of(item.unitPrice, "JPY"),
        item.quantity
      );
    }

    order.confirm();
    await this.orderRepo.save(order);

    return OrderResponse.fromDomain(order);
  }
}

// infrastructure/persistence/PrismaOrderRepository.ts
import { PrismaClient } from "@prisma/client";
import { IOrderRepository } from "../../domain/repository/IOrderRepository";
import { Order } from "../../domain/model/Order";
import { Money } from "../../domain/model/Money";
import { randomUUID } from "crypto";

export class PrismaOrderRepository implements IOrderRepository {
  constructor(private readonly prisma: PrismaClient) {}

  async findById(id: string): Promise<Order | null> {
    const record = await this.prisma.order.findUnique({
      where: { id },
      include: { items: true },
    });
    if (!record) return null;
    return this.toDomain(record);
  }

  async save(order: Order): Promise<void> {
    await this.prisma.order.upsert({
      where: { id: order.id },
      create: {
        id: order.id,
        customerId: order.customerId,
        status: order.status,
        items: {
          create: order.items.map((item) => ({
            productId: item.productId,
            unitPrice: item.unitPrice.amount,
            currency: item.unitPrice.currency,
            quantity: item.quantity,
          })),
        },
      },
      update: {
        status: order.status,
      },
    });
  }

  async nextId(): Promise<string> {
    return randomUUID();
  }

  private toDomain(record: any): Order {
    // DBレコードからドメインオブジェクトへの変換
    const order = Order.create(record.id, record.customerId);
    for (const item of record.items) {
      order.addItem(
        item.productId,
        Money.of(item.unitPrice, item.currency),
        item.quantity
      );
    }
    if (record.status === "confirmed") order.confirm();
    return order;
  }
}

// infrastructure/config/container.ts
import { PrismaClient } from "@prisma/client";
import { PrismaOrderRepository } from "../persistence/PrismaOrderRepository";
import { CreateOrderUseCase } from "../../application/usecase/CreateOrderUseCase";

// DIコンテナ：依存関係の組み立てはここで一括管理
const prisma = new PrismaClient();
const orderRepository = new PrismaOrderRepository(prisma);

export const createOrderUseCase = new CreateOrderUseCase(orderRepository);

// __tests__/CreateOrderUseCase.test.ts
import { CreateOrderUseCase } from "../application/usecase/CreateOrderUseCase";
import { IOrderRepository } from "../domain/repository/IOrderRepository";
import { Order } from "../domain/model/Order";

class InMemoryOrderRepository implements IOrderRepository {
  private store = new Map<string, Order>();
  private counter = 0;

  async findById(id: string): Promise<Order | null> {
    return this.store.get(id) ?? null;
  }

  async save(order: Order): Promise<void> {
    this.store.set(order.id, order);
  }

  async nextId(): Promise<string> {
    return `test-order-${++this.counter}`;
  }
}

describe("CreateOrderUseCase", () => {
  it("注文を作成して確定状態で保存する", async () => {
    const repo = new InMemoryOrderRepository();
    const useCase = new CreateOrderUseCase(repo);

    const result = await useCase.execute({
      customerId: "customer-1",
      items: [
        { productId: "product-A", unitPrice: 1000, quantity: 2 },
        { productId: "product-B", unitPrice: 500, quantity: 3 },
      ],
    });

    expect(result.status).toBe("confirmed");
    expect(result.totalAmount).toBe(3500);

    const saved = await repo.findById(result.id);
    expect(saved).not.toBeNull();
  });
});

project-root/
├── domain/
│   └── build.gradle       # 依存なし
├── application/
│   └── build.gradle       # implementation project(':domain')
├── infrastructure/
│   └── build.gradle       # implementation project(':domain', ':application')
└── settings.gradle

@AnalyzeClasses(packages = "com.example")
class ArchitectureTest {
    @ArchTest
    static final ArchRule domainShouldNotDependOnInfrastructure =
        noClasses()
            .that().resideInAPackage("..domain..")
            .should().dependOnClassesThat()
            .resideInAPackage("..infrastructure..");
}

// .dependency-cruiser.cjs（簡略例）
module.exports = {
  forbidden: [
    {
      name: "domain-cannot-import-infrastructure",
      from: { path: "^src/domain" },
      to: { path: "^src/infrastructure" },
    },
    {
      name: "domain-cannot-import-application",
      from: { path: "^src/domain" },
      to: { path: "^src/application" },
    },
  ],
};

order-service/
├── domain/
├── application/
└── infrastructure/

payment-service/
├── domain/
├── application/
└── infrastructure/

notification-service/
├── domain/
├── application/
└── infrastructure/