// ============================================================
// Domain Layer: Repository Interface
// domain/repositories/UserRepository.ts
// ============================================================
 
import { User } from "../entities/User";
 
export interface FindOptions {
  page?: number;
  perPage?: number;
  sortBy?: string;
  sortOrder?: "asc" | "desc";
  filter?: {
    active?: boolean;
    role?: string;
    createdAfter?: Date;
  };
}
 
export interface PaginatedResult<T> {
  data: T[];
  total: number;
  page: number;
  perPage: number;
  totalPages: number;
  hasNext: boolean;
  hasPrev: boolean;
}
 
// Repository Interface — ドメイン層で定義
export interface UserRepository {
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  findAll(options?: FindOptions): Promise<PaginatedResult<User>>;
  findByIds(ids: string[]): Promise<User[]>;
  save(user: User): Promise<User>;
  saveMany(users: User[]): Promise<User[]>;
  delete(id: string): Promise<void>;
  exists(email: string): Promise<boolean>;
  count(filter?: FindOptions["filter"]): Promise<number>;
}

// ============================================================
// Infrastructure Layer: PostgreSQL 実装（Prisma）
// infrastructure/repositories/PrismaUserRepository.ts
// ============================================================
 
import { PrismaClient, User as PrismaUser } from "@prisma/client";
import {
  UserRepository,
  FindOptions,
  PaginatedResult,
} from "../../domain/repositories/UserRepository";
import { User } from "../../domain/entities/User";
 
export class PrismaUserRepository implements UserRepository {
  constructor(private readonly prisma: PrismaClient) {}
 
  async findById(id: string): Promise<User | null> {
    const row = await this.prisma.user.findUnique({
      where: { id },
      include: { profile: true },  // 集約の関連エンティティも取得
    });
    return row ? this.toDomain(row) : null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    const row = await this.prisma.user.findUnique({
      where: { email },
    });
    return row ? this.toDomain(row) : null;
  }
 
  async findAll(options?: FindOptions): Promise<PaginatedResult<User>> {
    const page = options?.page ?? 1;
    const perPage = options?.perPage ?? 20;
    const skip = (page - 1) * perPage;
 
    // フィルター条件の構築
    const where: Record<string, unknown> = {};
    if (options?.filter?.active !== undefined) {
      where.active = options.filter.active;
    }
    if (options?.filter?.role) {
      where.role = options.filter.role;
    }
    if (options?.filter?.createdAfter) {
      where.createdAt = { gte: options.filter.createdAfter };
    }
 
    const [rows, total] = await Promise.all([
      this.prisma.user.findMany({
        where,
        skip,
        take: perPage,
        orderBy: {
          [options?.sortBy ?? "createdAt"]: options?.sortOrder ?? "desc",
        },
      }),
      this.prisma.user.count({ where }),
    ]);
 
    const totalPages = Math.ceil(total / perPage);
 
    return {
      data: rows.map((row) => this.toDomain(row)),
      total,
      page,
      perPage,
      totalPages,
      hasNext: page < totalPages,
      hasPrev: page > 1,
    };
  }
 
  async findByIds(ids: string[]): Promise<User[]> {
    const rows = await this.prisma.user.findMany({
      where: { id: { in: ids } },
    });
    return rows.map((row) => this.toDomain(row));
  }
 
  async save(user: User): Promise<User> {
    const row = await this.prisma.user.upsert({
      where: { id: user.id },
      create: {
        id: user.id,
        name: user.name,
        email: user.email,
        role: user.role,
        active: user.active,
      },
      update: {
        name: user.name,
        email: user.email,
        role: user.role,
        active: user.active,
        updatedAt: new Date(),
      },
    });
    return this.toDomain(row);
  }
 
  async saveMany(users: User[]): Promise<User[]> {
    const results = await this.prisma.$transaction(
      users.map((user) =>
        this.prisma.user.upsert({
          where: { id: user.id },
          create: {
            id: user.id,
            name: user.name,
            email: user.email,
            role: user.role,
            active: user.active,
          },
          update: {
            name: user.name,
            email: user.email,
            role: user.role,
            active: user.active,
          },
        })
      )
    );
    return results.map((row) => this.toDomain(row));
  }
 
  async delete(id: string): Promise<void> {
    await this.prisma.user.delete({ where: { id } });
  }
 
  async exists(email: string): Promise<boolean> {
    const count = await this.prisma.user.count({ where: { email } });
    return count > 0;
  }
 
  async count(filter?: FindOptions["filter"]): Promise<number> {
    const where: Record<string, unknown> = {};
    if (filter?.active !== undefined) where.active = filter.active;
    if (filter?.role) where.role = filter.role;
    return this.prisma.user.count({ where });
  }
 
  // ドメインモデルへの変換
  private toDomain(row: PrismaUser): User {
    return new User({
      id: row.id,
      name: row.name,
      email: row.email,
      role: row.role as "admin" | "user",
      active: row.active,
      createdAt: row.createdAt,
      updatedAt: row.updatedAt,
    });
  }
}

// ============================================================
// Test: In-Memory 実装
// tests/repositories/InMemoryUserRepository.ts
// ============================================================
 
export class InMemoryUserRepository implements UserRepository {
  private users: Map<string, User> = new Map();
 
  async findById(id: string): Promise<User | null> {
    return this.users.get(id) ?? null;
  }
 
  async findByEmail(email: string): Promise<User | null> {
    return (
      [...this.users.values()].find((u) => u.email === email) ?? null
    );
  }
 
  async findAll(options?: FindOptions): Promise<PaginatedResult<User>> {
    let all = [...this.users.values()];
 
    // フィルタリング
    if (options?.filter?.active !== undefined) {
      all = all.filter((u) => u.active === options.filter!.active);
    }
    if (options?.filter?.role) {
      all = all.filter((u) => u.role === options.filter!.role);
    }
    if (options?.filter?.createdAfter) {
      all = all.filter(
        (u) => u.createdAt >= options.filter!.createdAfter!
      );
    }
 
    // ソート
    const sortBy = options?.sortBy ?? "createdAt";
    const sortOrder = options?.sortOrder ?? "desc";
    all.sort((a, b) => {
      const aVal = (a as any)[sortBy];
      const bVal = (b as any)[sortBy];
      const cmp = aVal > bVal ? 1 : aVal < bVal ? -1 : 0;
      return sortOrder === "desc" ? -cmp : cmp;
    });
 
    // ページネーション
    const page = options?.page ?? 1;
    const perPage = options?.perPage ?? 20;
    const start = (page - 1) * perPage;
    const data = all.slice(start, start + perPage);
    const totalPages = Math.ceil(all.length / perPage);
 
    return {
      data,
      total: all.length,
      page,
      perPage,
      totalPages,
      hasNext: page < totalPages,
      hasPrev: page > 1,
    };
  }
 
  async findByIds(ids: string[]): Promise<User[]> {
    return ids
      .map((id) => this.users.get(id))
      .filter((u): u is User => u !== undefined);
  }
 
  async save(user: User): Promise<User> {
    this.users.set(user.id, user);
    return user;
  }
 
  async saveMany(users: User[]): Promise<User[]> {
    users.forEach((u) => this.users.set(u.id, u));
    return users;
  }
 
  async delete(id: string): Promise<void> {
    this.users.delete(id);
  }
 
  async exists(email: string): Promise<boolean> {
    return [...this.users.values()].some((u) => u.email === email);
  }
 
  async count(filter?: FindOptions["filter"]): Promise<number> {
    let all = [...this.users.values()];
    if (filter?.active !== undefined) {
      all = all.filter((u) => u.active === filter.active);
    }
    return all.length;
  }
 
  // テストヘルパー
  clear(): void {
    this.users.clear();
  }
 
  seed(users: User[]): void {
    users.forEach((u) => this.users.set(u.id, u));
  }
 
  getAll(): User[] {
    return [...this.users.values()];
  }
}

// ============================================================
// Application Layer: Service
// application/services/UserService.ts
// ============================================================
 
export class UserService {
  constructor(
    private readonly userRepo: UserRepository,   // インターフェースに依存
    private readonly emailService: EmailService,
    private readonly eventBus: EventBus,
  ) {}
 
  async registerUser(name: string, email: string): Promise<User> {
    // ビジネスルールの検証
    const existing = await this.userRepo.exists(email);
    if (existing) {
      throw new DuplicateEmailError(email);
    }
 
    // ドメインオブジェクト生成
    const user = User.create(name, email);
 
    // 永続化
    const saved = await this.userRepo.save(user);
 
    // 副作用（ドメインイベント発行）
    await this.eventBus.publish(new UserRegisteredEvent(saved));
    await this.emailService.sendWelcome(saved.email);
 
    return saved;
  }
 
  async deactivateUser(id: string): Promise<void> {
    const user = await this.userRepo.findById(id);
    if (!user) throw new UserNotFoundError(id);
 
    user.deactivate();
    await this.userRepo.save(user);
    await this.eventBus.publish(new UserDeactivatedEvent(user));
  }
 
  async getUserList(options?: FindOptions): Promise<PaginatedResult<User>> {
    return this.userRepo.findAll({
      ...options,
      filter: { ...options?.filter, active: true },
    });
  }
}
 
// ============================================================
// DI Container（tsyringe の例）
// ============================================================
import { container } from "tsyringe";
 
// 本番環境: PostgreSQL 実装を注入
container.register<UserRepository>("UserRepository", {
  useClass: PrismaUserRepository,
});
 
// テスト環境: InMemory 実装を注入
container.register<UserRepository>("UserRepository", {
  useClass: InMemoryUserRepository,
});

// ============================================================
// テスト — InMemory Repository を使用
// ============================================================
 
describe("UserService", () => {
  let service: UserService;
  let userRepo: InMemoryUserRepository;
  let emailService: jest.Mocked<EmailService>;
  let eventBus: jest.Mocked<EventBus>;
 
  beforeEach(() => {
    userRepo = new InMemoryUserRepository();
    emailService = { sendWelcome: jest.fn() } as any;
    eventBus = { publish: jest.fn() } as any;
    service = new UserService(userRepo, emailService, eventBus);
  });
 
  describe("registerUser", () => {
    test("新規ユーザーを登録できる", async () => {
      const user = await service.registerUser("Alice", "alice@example.com");
 
      // ドメインの検証
      expect(user.name).toBe("Alice");
      expect(user.email).toBe("alice@example.com");
      expect(user.active).toBe(true);
 
      // 永続化の検証
      const found = await userRepo.findByEmail("alice@example.com");
      expect(found).not.toBeNull();
      expect(found!.id).toBe(user.id);
 
      // 副作用の検証
      expect(emailService.sendWelcome).toHaveBeenCalledWith("alice@example.com");
      expect(eventBus.publish).toHaveBeenCalledWith(
        expect.objectContaining({ type: "UserRegistered" })
      );
    });
 
    test("重複メールアドレスはエラー", async () => {
      await service.registerUser("Alice", "alice@example.com");
 
      await expect(
        service.registerUser("Bob", "alice@example.com")
      ).rejects.toThrow(DuplicateEmailError);
 
      // 副作用が呼ばれないことを検証
      expect(emailService.sendWelcome).toHaveBeenCalledTimes(1);
    });
  });
 
  describe("deactivateUser", () => {
    test("ユーザーを無効化できる", async () => {
      const user = await service.registerUser("Alice", "alice@example.com");
      await service.deactivateUser(user.id);
 
      const found = await userRepo.findById(user.id);
      expect(found!.active).toBe(false);
    });
 
    test("存在しないユーザーはエラー", async () => {
      await expect(
        service.deactivateUser("non-existent-id")
      ).rejects.toThrow(UserNotFoundError);
    });
  });
 
  describe("getUserList", () => {
    test("アクティブユーザーのみ返す", async () => {
      const alice = await service.registerUser("Alice", "alice@example.com");
      await service.registerUser("Bob", "bob@example.com");
      await service.deactivateUser(alice.id);
 
      const result = await service.getUserList();
      expect(result.data).toHaveLength(1);
      expect(result.data[0].name).toBe("Bob");
    });
  });
});

# ============================================================
# domain/repositories/user_repository.py
# ============================================================
from abc import ABC, abstractmethod
from typing import Optional, List
from dataclasses import dataclass
from domain.entities.user import User
 
 
@dataclass
class FindOptions:
    page: int = 1
    per_page: int = 20
    sort_by: str = "created_at"
    sort_order: str = "desc"
    active: Optional[bool] = None
    role: Optional[str] = None
 
 
@dataclass
class PaginatedResult:
    data: List[User]
    total: int
    page: int
    per_page: int
 
    @property
    def total_pages(self) -> int:
        return -(-self.total // self.per_page)  # 切り上げ除算
 
    @property
    def has_next(self) -> bool:
        return self.page < self.total_pages
 
    @property
    def has_prev(self) -> bool:
        return self.page > 1
 
 
class UserRepository(ABC):
    """ユーザーリポジトリインターフェース（ドメイン層で定義）"""
 
    @abstractmethod
    async def find_by_id(self, user_id: str) -> Optional[User]:
        ...
 
    @abstractmethod
    async def find_by_email(self, email: str) -> Optional[User]:
        ...
 
    @abstractmethod
    async def find_all(self, options: Optional[FindOptions] = None) -> PaginatedResult:
        ...
 
    @abstractmethod
    async def save(self, user: User) -> User:
        ...
 
    @abstractmethod
    async def delete(self, user_id: str) -> None:
        ...
 
    @abstractmethod
    async def exists(self, email: str) -> bool:
        ...

# ============================================================
# infrastructure/repositories/sqlalchemy_user_repository.py
# ============================================================
from sqlalchemy import select, func
from sqlalchemy.ext.asyncio import AsyncSession
from domain.repositories.user_repository import (
    UserRepository, FindOptions, PaginatedResult
)
from domain.entities.user import User
from infrastructure.models import UserModel
 
 
class SQLAlchemyUserRepository(UserRepository):
    """SQLAlchemy を使った PostgreSQL 実装"""
 
    def __init__(self, session: AsyncSession):
        self._session = session
 
    async def find_by_id(self, user_id: str) -> Optional[User]:
        stmt = select(UserModel).where(UserModel.id == user_id)
        result = await self._session.execute(stmt)
        row = result.scalar_one_or_none()
        return self._to_domain(row) if row else None
 
    async def find_by_email(self, email: str) -> Optional[User]:
        stmt = select(UserModel).where(UserModel.email == email)
        result = await self._session.execute(stmt)
        row = result.scalar_one_or_none()
        return self._to_domain(row) if row else None
 
    async def find_all(self, options: Optional[FindOptions] = None) -> PaginatedResult:
        opts = options or FindOptions()
 
        # 基本クエリ
        stmt = select(UserModel)
        count_stmt = select(func.count()).select_from(UserModel)
 
        # フィルター
        if opts.active is not None:
            stmt = stmt.where(UserModel.active == opts.active)
            count_stmt = count_stmt.where(UserModel.active == opts.active)
        if opts.role:
            stmt = stmt.where(UserModel.role == opts.role)
            count_stmt = count_stmt.where(UserModel.role == opts.role)
 
        # ソート
        sort_col = getattr(UserModel, opts.sort_by, UserModel.created_at)
        stmt = stmt.order_by(
            sort_col.desc() if opts.sort_order == "desc" else sort_col.asc()
        )
 
        # ページネーション
        offset = (opts.page - 1) * opts.per_page
        stmt = stmt.offset(offset).limit(opts.per_page)
 
        # 実行
        result = await self._session.execute(stmt)
        count_result = await self._session.execute(count_stmt)
        rows = result.scalars().all()
        total = count_result.scalar()
 
        return PaginatedResult(
            data=[self._to_domain(row) for row in rows],
            total=total,
            page=opts.page,
            per_page=opts.per_page,
        )
 
    async def save(self, user: User) -> User:
        model = UserModel(
            id=user.id,
            name=user.name,
            email=user.email,
            role=user.role,
            active=user.active,
        )
        merged = await self._session.merge(model)
        await self._session.flush()
        return self._to_domain(merged)
 
    async def delete(self, user_id: str) -> None:
        stmt = select(UserModel).where(UserModel.id == user_id)
        result = await self._session.execute(stmt)
        model = result.scalar_one()
        await self._session.delete(model)
 
    async def exists(self, email: str) -> bool:
        stmt = select(func.count()).select_from(UserModel).where(
            UserModel.email == email
        )
        result = await self._session.execute(stmt)
        return result.scalar() > 0
 
    def _to_domain(self, model: UserModel) -> User:
        return User(
            id=model.id,
            name=model.name,
            email=model.email,
            role=model.role,
            active=model.active,
            created_at=model.created_at,
        )

# ============================================================
# テスト用 InMemory 実装
# tests/repositories/in_memory_user_repository.py
# ============================================================
class InMemoryUserRepository(UserRepository):
    def __init__(self):
        self._users: dict[str, User] = {}
 
    async def find_by_id(self, user_id: str) -> Optional[User]:
        return self._users.get(user_id)
 
    async def find_by_email(self, email: str) -> Optional[User]:
        return next(
            (u for u in self._users.values() if u.email == email), None
        )
 
    async def find_all(self, options: Optional[FindOptions] = None) -> PaginatedResult:
        opts = options or FindOptions()
        users = list(self._users.values())
 
        # フィルター
        if opts.active is not None:
            users = [u for u in users if u.active == opts.active]
        if opts.role:
            users = [u for u in users if u.role == opts.role]
 
        # ページネーション
        total = len(users)
        start = (opts.page - 1) * opts.per_page
        data = users[start:start + opts.per_page]
 
        return PaginatedResult(
            data=data, total=total, page=opts.page, per_page=opts.per_page
        )
 
    async def save(self, user: User) -> User:
        self._users[user.id] = user
        return user
 
    async def delete(self, user_id: str) -> None:
        self._users.pop(user_id, None)
 
    async def exists(self, email: str) -> bool:
        return any(u.email == email for u in self._users.values())
 
    def clear(self):
        self._users.clear()

// NG: 検索条件ごとにメソッドが増殖
interface UserRepository {
  findByName(name: string): Promise<User[]>;
  findByRole(role: string): Promise<User[]>;
  findByNameAndRole(name: string, role: string): Promise<User[]>;
  findActiveByRole(role: string): Promise<User[]>;
  findInactiveCreatedBefore(date: Date): Promise<User[]>;
  // ... 無限に増える
}
 
// OK: Specification パターンで条件をオブジェクト化
interface UserRepository {
  findAll(spec?: Specification<User>): Promise<User[]>;
  // 1つのメソッドで全ての検索条件に対応
}

// ============================================================
// Specification パターン
// ============================================================
 
// 基底 Specification
interface Specification<T> {
  isSatisfiedBy(entity: T): boolean;
  toSQL(): { where: string; params: unknown[] };
  and(other: Specification<T>): Specification<T>;
  or(other: Specification<T>): Specification<T>;
  not(): Specification<T>;
}
 
abstract class BaseSpecification<T> implements Specification<T> {
  abstract isSatisfiedBy(entity: T): boolean;
  abstract toSQL(): { where: string; params: unknown[] };
 
  and(other: Specification<T>): Specification<T> {
    return new AndSpecification(this, other);
  }
 
  or(other: Specification<T>): Specification<T> {
    return new OrSpecification(this, other);
  }
 
  not(): Specification<T> {
    return new NotSpecification(this);
  }
}
 
class AndSpecification<T> extends BaseSpecification<T> {
  constructor(private left: Specification<T>, private right: Specification<T>) {
    super();
  }
 
  isSatisfiedBy(entity: T): boolean {
    return this.left.isSatisfiedBy(entity) && this.right.isSatisfiedBy(entity);
  }
 
  toSQL(): { where: string; params: unknown[] } {
    const l = this.left.toSQL();
    const r = this.right.toSQL();
    return {
      where: `(${l.where}) AND (${r.where})`,
      params: [...l.params, ...r.params],
    };
  }
}
 
class OrSpecification<T> extends BaseSpecification<T> {
  constructor(private left: Specification<T>, private right: Specification<T>) {
    super();
  }
 
  isSatisfiedBy(entity: T): boolean {
    return this.left.isSatisfiedBy(entity) || this.right.isSatisfiedBy(entity);
  }
 
  toSQL(): { where: string; params: unknown[] } {
    const l = this.left.toSQL();
    const r = this.right.toSQL();
    return {
      where: `(${l.where}) OR (${r.where})`,
      params: [...l.params, ...r.params],
    };
  }
}
 
class NotSpecification<T> extends BaseSpecification<T> {
  constructor(private spec: Specification<T>) {
    super();
  }
 
  isSatisfiedBy(entity: T): boolean {
    return !this.spec.isSatisfiedBy(entity);
  }
 
  toSQL(): { where: string; params: unknown[] } {
    const s = this.spec.toSQL();
    return { where: `NOT (${s.where})`, params: s.params };
  }
}
 
// 具体的な Specification
class ActiveUserSpec extends BaseSpecification<User> {
  isSatisfiedBy(user: User): boolean {
    return user.active;
  }
 
  toSQL() {
    return { where: "active = true", params: [] };
  }
}
 
class UserWithRoleSpec extends BaseSpecification<User> {
  constructor(private role: string) {
    super();
  }
 
  isSatisfiedBy(user: User): boolean {
    return user.role === this.role;
  }
 
  toSQL() {
    return { where: "role = $1", params: [this.role] };
  }
}
 
class CreatedAfterSpec extends BaseSpecification<User> {
  constructor(private date: Date) {
    super();
  }
 
  isSatisfiedBy(user: User): boolean {
    return user.createdAt >= this.date;
  }
 
  toSQL() {
    return { where: "created_at >= $1", params: [this.date] };
  }
}
 
// 使用例: 条件を組み合わせ
const activeAdmins = new ActiveUserSpec().and(new UserWithRoleSpec("admin"));
const recentOrAdmin = new CreatedAfterSpec(lastMonth).or(new UserWithRoleSpec("admin"));
 
// Repository での使用
const users = await userRepo.findAll(activeAdmins);

// ============================================================
// Unit of Work インターフェース
// ============================================================
interface UnitOfWork {
  readonly users: UserRepository;
  readonly orders: OrderRepository;
  readonly auditLogs: AuditLogRepository;
  commit(): Promise<void>;
  rollback(): Promise<void>;
}
 
// ============================================================
// Prisma 実装
// ============================================================
class PrismaUnitOfWork implements UnitOfWork {
  readonly users: UserRepository;
  readonly orders: OrderRepository;
  readonly auditLogs: AuditLogRepository;
 
  private constructor(private tx: PrismaClient) {
    this.users = new PrismaUserRepository(tx);
    this.orders = new PrismaOrderRepository(tx);
    this.auditLogs = new PrismaAuditLogRepository(tx);
  }
 
  // ファクトリメソッド: トランザクション内で実行
  static async execute<T>(
    prisma: PrismaClient,
    fn: (uow: UnitOfWork) => Promise<T>
  ): Promise<T> {
    return prisma.$transaction(async (tx) => {
      const uow = new PrismaUnitOfWork(tx as PrismaClient);
      return fn(uow);
    });
  }
 
  async commit(): Promise<void> {
    // Prisma $transaction は自動コミット
  }
 
  async rollback(): Promise<void> {
    // Prisma $transaction は例外時に自動ロールバック
    throw new Error("Transaction aborted");
  }
}
 
// ============================================================
// Service での使用
// ============================================================
class OrderService {
  constructor(
    private prisma: PrismaClient,
    private eventBus: EventBus,
  ) {}
 
  async placeOrder(userId: string, items: OrderItem[]): Promise<Order> {
    const result = await PrismaUnitOfWork.execute(this.prisma, async (uow) => {
      // 1. ユーザー取得
      const user = await uow.users.findById(userId);
      if (!user) throw new UserNotFoundError(userId);
 
      // 2. 注文作成（ドメインロジック）
      const order = Order.create(user, items);
 
      // 3. 注文保存
      await uow.orders.save(order);
 
      // 4. ユーザーのポイント更新
      user.addPoints(order.calculatePoints());
      await uow.users.save(user);
 
      // 5. 監査ログ記録
      await uow.auditLogs.append(
        AuditLog.create("ORDER_PLACED", userId, { orderId: order.id })
      );
 
      return order;
    });
    // 全ての変更がトランザクション内で一括コミットされる
 
    // トランザクション成功後にイベント発行
    await this.eventBus.publish(new OrderPlacedEvent(result));
 
    return result;
  }
}

// NG: Repository のインターフェースに Prisma の型が漏洩
interface UserRepository {
  findMany(args: Prisma.UserFindManyArgs): Promise<PrismaUser[]>;
  //       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^
  //       インフラ層の型がドメイン層に漏洩
}
 
// OK: ドメイン層の型のみを使用
interface UserRepository {
  findAll(options?: FindOptions): Promise<PaginatedResult<User>>;
  //                ^^^^^^^^^^^                            ^^^^
  //                ドメイン層で定義した型のみ
}

// NG: 全てのエンティティに同じ CRUD を提供
interface GenericRepository<T> {
  findById(id: string): Promise<T | null>;
  findAll(): Promise<T[]>;
  save(entity: T): Promise<T>;
  delete(id: string): Promise<void>;
}
 
// 問題: ドメインルールを表現できない
// 「ログは削除禁止」「設定は常に1つ」等
 
// OK: ドメインの要件に合わせたインターフェース
interface AuditLogRepository {
  append(log: AuditLog): Promise<void>;  // 追記のみ、削除不可
  findByDateRange(from: Date, to: Date): Promise<AuditLog[]>;
  // delete() メソッドは意図的に存在しない
}
 
interface AppSettingsRepository {
  get(): Promise<AppSettings>;           // 常に1つ
  update(settings: AppSettings): Promise<void>;
  // findAll() や delete() は不要
}
 
interface OrderRepository {
  findById(id: string): Promise<Order>;  // Order + OrderItems を含む
  save(order: Order): Promise<void>;     // Order + OrderItems を一括保存
  // save は集約全体を保存、個別の OrderItem の CRUD は提供しない
}

// NG: Repository がビジネスルールを知っている
class PostgresUserRepository implements UserRepository {
  async save(user: User): Promise<User> {
    // ビジネスルールの検証が Repository に混在
    if (!user.email.includes("@")) {
      throw new Error("Invalid email");
    }
    // VIP判定のロジックが Repository に
    if (user.purchaseTotal > 100000) {
      user.role = "vip";
    }
    return this.prisma.user.upsert(/* ... */);
  }
}
 
// OK: Repository は永続化のみ、ビジネスロジックはドメイン層
class User {
  // ビジネスルールはエンティティに
  updateEmail(newEmail: string): void {
    if (!newEmail.includes("@")) {
      throw new InvalidEmailError(newEmail);
    }
    this.email = newEmail;
  }
 
  checkVipStatus(): void {
    if (this.purchaseTotal > 100000) {
      this.role = "vip";
    }
  }
}
 
class PostgresUserRepository implements UserRepository {
  async save(user: User): Promise<User> {
    // 永続化のみ。バリデーションやビジネスロジックは含まない
    return this.prisma.user.upsert(/* ... */);
  }
}

// NG: まだ1種類のDBしか使わないのに抽象化しすぎ
interface IRepositoryFactory<T> {
  createRepository(type: "postgres" | "mongo" | "dynamodb"): IRepository<T>;
}
 
interface IRepository<T> extends ICrudRepository<T>, ISearchRepository<T>, IAuditableRepository<T> {
  // ...
}
 
// OK: 必要になった時点で抽象化
// 現時点では Prisma 直接使用で十分なら:
class UserRepository {
  constructor(private prisma: PrismaClient) {}
 
  async findById(id: string): Promise<User | null> {
    // ...
  }
}
// テスト時にだけ InMemory に差し替えたい場合に Interface を導入

class BookingService {
  constructor(
    private roomRepo: RoomRepository,
    private bookingRepo: BookingRepository,
  ) {}
 
  async createBooking(roomId: string, userId: string, date: Date): Promise<Booking> {
    const room = await this.roomRepo.findById(roomId);
    if (!room) throw new RoomNotFoundError(roomId);
    if (!room.isAvailable) throw new RoomUnavailableError(roomId);
 
    const existingBooking = await this.bookingRepo.findByRoomAndDate(roomId, date);
    if (existingBooking) throw new DoubleBookingError(roomId, date);
 
    const booking = Booking.create(roomId, userId, date);
    return this.bookingRepo.save(booking);
  }
}

// DDD: 集約ルート単位
interface OrderRepository {
  findById(id: string): Promise<Order>;
  // ↑ Order + OrderItems + ShippingAddress を含む集約全体を返す
  save(order: Order): Promise<void>;
  // ↑ Order + OrderItems + ShippingAddress を一括保存
}
 
// 非DDD: テーブル単位
interface OrderRepository {
  findById(id: string): Promise<Order>;  // Order のみ
}
interface OrderItemRepository {
  findByOrderId(orderId: string): Promise<OrderItem[]>;
}

// 統合テスト: TestContainers で PostgreSQL を起動
describe("PrismaUserRepository (Integration)", () => {
  let prisma: PrismaClient;
  let repo: PrismaUserRepository;
 
  beforeAll(async () => {
    // Docker で PostgreSQL コンテナを起動
    const container = await new PostgreSqlContainer().start();
    prisma = new PrismaClient({
      datasources: { db: { url: container.getConnectionUri() } },
    });
    await prisma.$executeRaw`CREATE TABLE ...`;
    repo = new PrismaUserRepository(prisma);
  });
 
  test("save and findById", async () => {
    const user = User.create("Alice", "alice@example.com");
    await repo.save(user);
 
    const found = await repo.findById(user.id);
    expect(found).not.toBeNull();
    expect(found!.email).toBe("alice@example.com");
  });
});

// OK: ドメインエンティティを返す
interface UserRepository {
  findById(id: string): Promise<User>;  // ← User はドメインエンティティ
}
 
// NG: DTO を返す
interface UserRepository {
  findById(id: string): Promise<UserResponseDTO>;  // ← これは Controller の仕事
}

// キャッシュ付き Repository（Decorator パターン）
class CachedUserRepository implements UserRepository {
  constructor(
    private inner: UserRepository,  // 実際の DB Repository
    private cache: CacheClient,     // Redis 等
    private ttl: number = 300,      // 5分
  ) {}
 
  async findById(id: string): Promise<User | null> {
    // 1. キャッシュ確認
    const cached = await this.cache.get(`user:${id}`);
    if (cached) return JSON.parse(cached);
 
    // 2. DB から取得
    const user = await this.inner.findById(id);
    if (user) {
      await this.cache.set(`user:${id}`, JSON.stringify(user), this.ttl);
    }
    return user;
  }
 
  async save(user: User): Promise<User> {
    const saved = await this.inner.save(user);
    // キャッシュ無効化
    await this.cache.del(`user:${saved.id}`);
    return saved;
  }
 
  // ... 他のメソッドも同様
}
 
// DI 設定
const dbRepo = new PrismaUserRepository(prisma);
const cachedRepo = new CachedUserRepository(dbRepo, redis);
container.register<UserRepository>("UserRepository", { useValue: cachedRepo });