エンティティ（エンティティ）

// Entity
export class Order {
  private constructor(
    public readonly id: OrderId,
    private items: OrderItem[],
    private status: OrderStatus,
    private readonly createdAt: Date,
  ) {}

  static create(params: CreateOrderParams): Order {
    if (params.items.length === 0) {
      throw new DomainError("注文には最低 1 商品が必要");
    }
    return new Order(
      OrderId.generate(),
      params.items,
      OrderStatus.Pending,
      new Date(),
    );
  }

  // ビジネスメソッド
  cancel(): void {
    if (this.status !== OrderStatus.Pending) {
      throw new DomainError("Pending のみキャンセル可");
    }
    this.status = OrderStatus.Cancelled;
  }

  // 計算メソッド（Value Object 返す）
  totalAmount(): Money {
    return this.items.reduce(
      (sum, item) => sum.add(item.subtotal()),
      Money.zero(),
    );
  }

  // 永続化用（ID + 必要最小限）
  toJSON() {
    return {
      id: this.id.value,
      items: this.items.map(i => i.toJSON()),
      status: this.status,
      createdAt: this.createdAt.toISOString(),
    };
  }
}

Order（Aggregate Root）
├── OrderItem（Entity）×N
├── ShippingAddress（Value Object）
└── Payment（Value Object）

export interface OrderRepository {
  findById(id: OrderId): Promise<Order | null>;
  save(order: Order): Promise<void>;
  delete(id: OrderId): Promise<void>;
}

export class OrderFactory {
  static fromCart(cart: Cart, address: Address, payment: Payment): Order {
    // 複雑なバリデーション + 変換
    return Order.create({...});
  }
}

apps/jisakucom-api/src/domain/
├── entities/
│   ├── product.entity.ts（34 ファイル全 Entity）
│   ├── faq.entity.ts
│   ├── pc-template.entity.ts
│   └── article.entity.ts
└── value-objects/
    ├── price.vo.ts
    ├── rating.vo.ts
    └── ...

// Kotlin Data Class（Value Object）+ Entity
data class OrderId(val value: String)
data class Money(val amount: BigDecimal, val currency: String)

class Order(
    val id: OrderId,
    private val items: MutableList<OrderItem>,
    private var status: OrderStatus,
) {
    fun cancel() {
        require(status == OrderStatus.Pending) { "Pending のみキャンセル可" }
        status = OrderStatus.Cancelled
    }
}

pub struct Order {
    pub id: OrderId,
    items: Vec<OrderItem>,
    status: OrderStatus,
}

impl Order {
    pub fn new(items: Vec<OrderItem>) -> Result<Self, DomainError> {
        if items.is_empty() {
            return Err(DomainError::EmptyItems);
        }
        Ok(Order {
            id: OrderId::new(),
            items,
            status: OrderStatus::Pending,
        })
    }

    pub fn cancel(&mut self) -> Result<(), DomainError> {
        if self.status != OrderStatus::Pending {
            return Err(DomainError::InvalidStatus);
        }
        self.status = OrderStatus::Cancelled;
        Ok(())
    }
}