// === Prisma (schema.prisma) ===
model User {
  id        String   @id @default(uuid())
  name      String
  email     String   @unique
  posts     Post[]
  createdAt DateTime @default(now())
}
 
model Post {
  id        String   @id @default(uuid())
  title     String
  body      String
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  String
}

// === TypeORM (Entity デコレータ) ===
import { Entity, PrimaryGeneratedColumn, Column, OneToMany, ManyToOne } from "typeorm";
 
@Entity()
export class User {
  @PrimaryGeneratedColumn("uuid")
  id: string;
 
  @Column()
  name: string;
 
  @Column({ unique: true })
  email: string;
 
  @OneToMany(() => Post, (post) => post.author)
  posts: Post[];
 
  @Column({ type: "timestamp", default: () => "NOW()" })
  createdAt: Date;
}
 
@Entity()
export class Post {
  @PrimaryGeneratedColumn("uuid")
  id: string;
 
  @Column()
  title: string;
 
  @Column("text")
  body: string;
 
  @Column({ default: false })
  published: boolean;
 
  @ManyToOne(() => User, (user) => user.posts)
  author: User;
}

// === Drizzle (TypeScript スキーマ) ===
import { pgTable, uuid, varchar, text, boolean, timestamp } from "drizzle-orm/pg-core";
import { relations } from "drizzle-orm";
 
export const users = pgTable("users", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: varchar("name", { length: 255 }).notNull(),
  email: varchar("email", { length: 255 }).notNull().unique(),
  createdAt: timestamp("created_at").defaultNow().notNull(),
});
 
export const posts = pgTable("posts", {
  id: uuid("id").primaryKey().defaultRandom(),
  title: varchar("title", { length: 255 }).notNull(),
  body: text("body").notNull(),
  published: boolean("published").default(false).notNull(),
  authorId: uuid("author_id").notNull().references(() => users.id),
});
 
// リレーション定義（Drizzleのrelational query用）
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));
 
export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}));

# === SQLAlchemy (Mapped 型注釈) ===
from sqlalchemy import String, Boolean, ForeignKey
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
from datetime import datetime
import uuid
 
class Base(DeclarativeBase):
    pass
 
class User(Base):
    __tablename__ = "users"
 
    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
    name: Mapped[str] = mapped_column(String(255))
    email: Mapped[str] = mapped_column(String(255), unique=True)
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
 
    posts: Mapped[list["Post"]] = relationship(back_populates="author")
 
class Post(Base):
    __tablename__ = "posts"
 
    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
    title: Mapped[str] = mapped_column(String(255))
    body: Mapped[str]
    published: Mapped[bool] = mapped_column(default=False)
    author_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
 
    author: Mapped["User"] = relationship(back_populates="posts")

// === Prisma ===
const usersWithPosts = await prisma.user.findMany({
  where: { email: { contains: "@example.com" } },
  include: {
    posts: {
      where: { published: true },
      orderBy: { createdAt: "desc" },
      take: 5,
    },
  },
  take: 10,
});
 
// Prisma の生成SQL:
// SELECT "User"."id", "User"."name", "User"."email", "User"."createdAt"
// FROM "User"
// WHERE "User"."email" LIKE '%@example.com%'
// LIMIT 10;
//
// SELECT "Post"."id", "Post"."title", ...
// FROM "Post"
// WHERE "Post"."authorId" IN ($1, $2, ...) AND "Post"."published" = true
// ORDER BY "Post"."createdAt" DESC
// LIMIT 5;
// → 2クエリで実行（N+1ではない）
 
// === TypeORM ===
const usersWithPosts = await userRepository.find({
  where: { email: Like("%@example.com") },
  relations: { posts: true },
  take: 10,
});
// TypeORM ではリレーションのフィルタは QueryBuilder が必要
const usersWithPosts2 = await userRepository
  .createQueryBuilder("user")
  .leftJoinAndSelect("user.posts", "post", "post.published = :pub", { pub: true })
  .where("user.email LIKE :email", { email: "%@example.com" })
  .orderBy("post.createdAt", "DESC")
  .take(10)
  .getMany();
 
// === Drizzle ===
const usersWithPosts = await db.query.users.findMany({
  where: like(users.email, "%@example.com"),
  with: {
    posts: {
      where: eq(posts.published, true),
      orderBy: desc(posts.createdAt),
      limit: 5,
    },
  },
  limit: 10,
});
 
// Drizzle のSQL-likeクエリ構築（低レベルAPI）
const result = await db
  .select({
    userName: users.name,
    postTitle: posts.title,
  })
  .from(users)
  .leftJoin(posts, eq(users.id, posts.authorId))
  .where(like(users.email, "%@example.com"))
  .limit(10);

# === SQLAlchemy ===
from sqlalchemy import select
from sqlalchemy.orm import selectinload
 
stmt = (
    select(User)
    .where(User.email.contains("@example.com"))
    .options(
        selectinload(User.posts).where(Post.published == True)
    )
    .limit(10)
)
users_with_posts = session.scalars(stmt).all()
 
# SQLAlchemy のローディング戦略比較
# 1. Lazy Loading（デフォルト）: アクセス時にクエリ → N+1問題の原因
# 2. Eager Loading (joinedload): JOINで一括取得
# 3. Subquery Loading (selectinload): サブクエリで一括取得（推奨）
# 4. Raise Loading (raiseload): アクセス時にエラー → N+1を検出
 
stmt_joined = (
    select(User)
    .options(joinedload(User.posts))  # LEFT JOINで取得
    .limit(10)
)
 
stmt_subquery = (
    select(User)
    .options(selectinload(User.posts))  # 別クエリで取得（推奨）
    .limit(10)
)
 
# raiseload: 明示的にロードしないとエラー（N+1検出用）
from sqlalchemy.orm import raiseload
stmt_strict = (
    select(User)
    .options(raiseload(User.posts))  # user.postsアクセスでエラー
)

// === Prisma ===
const users = await prisma.user.createMany({
  data: [
    { name: "Alice", email: "alice@example.com" },
    { name: "Bob", email: "bob@example.com" },
  ],
  skipDuplicates: true,
});
 
// Prisma: ネストされたリレーション作成
const userWithPosts = await prisma.user.create({
  data: {
    name: "Charlie",
    email: "charlie@example.com",
    posts: {
      create: [
        { title: "First Post", body: "Hello World", published: true },
        { title: "Draft", body: "WIP", published: false },
      ],
    },
  },
  include: { posts: true },
});
 
// === Drizzle ===
const inserted = await db.insert(users).values([
  { name: "Alice", email: "alice@example.com" },
  { name: "Bob", email: "bob@example.com" },
]).onConflictDoNothing().returning();
 
// Drizzle: UPSERT (ON CONFLICT)
const upserted = await db.insert(users).values({
  name: "Alice",
  email: "alice@example.com",
}).onConflictDoUpdate({
  target: users.email,
  set: { name: "Alice Updated" },
}).returning();
 
// === TypeORM ===
const result = await userRepository.insert([
  { name: "Alice", email: "alice@example.com" },
  { name: "Bob", email: "bob@example.com" },
]);
// TypeORM: UPSERT
await userRepository.upsert(
  { name: "Alice", email: "alice@example.com" },
  ["email"]
);

# === SQLAlchemy ===
session.add_all([
    User(name="Alice", email="alice@example.com"),
    User(name="Bob", email="bob@example.com"),
])
session.commit()
 
# SQLAlchemy: バルクINSERT（高速版）
from sqlalchemy import insert
stmt = insert(User).values([
    {"name": "Alice", "email": "alice@example.com"},
    {"name": "Bob", "email": "bob@example.com"},
])
session.execute(stmt)
session.commit()
 
# SQLAlchemy: UPSERT (PostgreSQL)
from sqlalchemy.dialects.postgresql import insert as pg_insert
stmt = pg_insert(User).values(name="Alice", email="alice@example.com")
stmt = stmt.on_conflict_do_update(
    index_elements=["email"],
    set_={"name": stmt.excluded.name},
)
session.execute(stmt)
session.commit()

// === Prisma: Interactive Transaction ===
const result = await prisma.$transaction(async (tx) => {
  const user = await tx.user.create({
    data: { name: "Alice", email: "alice@example.com" },
  });
  const post = await tx.post.create({
    data: { title: "Hello", body: "World", authorId: user.id },
  });
  return { user, post };
});
// 例外が発生すると自動ロールバック
 
// Prisma: Sequential Transaction（複数操作をアトミックに）
const [user, post] = await prisma.$transaction([
  prisma.user.create({ data: { name: "Bob", email: "bob@example.com" } }),
  prisma.post.create({ data: { title: "Hi", body: "!", authorId: "..." } }),
]);
 
// === Drizzle ===
const result = await db.transaction(async (tx) => {
  const [user] = await tx.insert(users).values({
    name: "Alice", email: "alice@example.com"
  }).returning();
 
  await tx.insert(posts).values({
    title: "Hello", body: "World", authorId: user.id
  });
 
  return user;
});
 
// === TypeORM: QueryRunner ===
const queryRunner = dataSource.createQueryRunner();
await queryRunner.startTransaction();
try {
  const user = queryRunner.manager.create(User, {
    name: "Alice", email: "alice@example.com"
  });
  await queryRunner.manager.save(user);
 
  const post = queryRunner.manager.create(Post, {
    title: "Hello", body: "World", author: user
  });
  await queryRunner.manager.save(post);
 
  await queryRunner.commitTransaction();
} catch (err) {
  await queryRunner.rollbackTransaction();
  throw err;
} finally {
  await queryRunner.release();
}

# === SQLAlchemy: Session ===
# 方法1: コンテキストマネージャ（推奨）
with Session(engine) as session:
    with session.begin():  # 自動commit/rollback
        user = User(name="Alice", email="alice@example.com")
        session.add(user)
        session.flush()  # IDを取得するためにflush
 
        post = Post(title="Hello", body="World", author=user)
        session.add(post)
    # ブロック終了時に自動commit
 
# 方法2: 明示的なcommit/rollback
session = Session(engine)
try:
    user = User(name="Alice", email="alice@example.com")
    session.add(user)
    session.flush()
 
    post = Post(title="Hello", body="World", author=user)
    session.add(post)
    session.commit()
except Exception:
    session.rollback()
    raise
finally:
    session.close()
 
# 方法3: ネストトランザクション（SAVEPOINT）
with Session(engine) as session:
    with session.begin():
        session.add(User(name="Alice", email="alice@example.com"))
 
        # ネストトランザクション（SAVEPOINT）
        with session.begin_nested():
            try:
                session.add(User(name="Alice", email="alice@example.com"))  # 重複
                session.flush()
            except IntegrityError:
                pass  # SAVEPOINTにロールバック、外側は続行
 
        session.add(User(name="Bob", email="bob@example.com"))
    # Alice + Bob がコミット（重複Aliceはロールバック済み）

# === Prisma ===
# 開発環境: スキーマの差分からマイグレーション生成
npx prisma migrate dev --name add_user_avatar
 
# 本番環境: マイグレーション適用のみ（生成はしない）
npx prisma migrate deploy
 
# スキーマの状態をDBにプッシュ（プロトタイプ用、マイグレーションなし）
npx prisma db push
 
# === Drizzle ===
# マイグレーションファイル生成
npx drizzle-kit generate
 
# マイグレーション適用
npx drizzle-kit migrate
 
# === TypeORM ===
# マイグレーション生成（Entityの差分を検知）
npx typeorm migration:generate -n AddUserAvatar
 
# マイグレーション適用
npx typeorm migration:run
 
# === SQLAlchemy + Alembic ===
# 初期化
alembic init alembic
 
# マイグレーション生成（自動検知）
alembic revision --autogenerate -m "add user avatar"
 
# マイグレーション適用
alembic upgrade head
 
# ロールバック
alembic downgrade -1

// === Prisma: $queryRaw ===
const users = await prisma.$queryRaw<User[]>`
  SELECT u.*, COUNT(p.id) as post_count
  FROM "User" u
  LEFT JOIN "Post" p ON p."authorId" = u.id
  GROUP BY u.id
  HAVING COUNT(p.id) > ${minPosts}
  ORDER BY post_count DESC
`;
 
// === Drizzle: sql テンプレート ===
import { sql } from "drizzle-orm";
 
const result = await db.execute(sql`
  SELECT ${users.name}, COUNT(${posts.id}) as post_count
  FROM ${users}
  LEFT JOIN ${posts} ON ${posts.authorId} = ${users.id}
  GROUP BY ${users.name}
  HAVING COUNT(${posts.id}) > ${minPosts}
`);
 
// === TypeORM: Query ===
const result = await dataSource.query(
  `SELECT u.*, COUNT(p.id) as post_count
   FROM "user" u
   LEFT JOIN "post" p ON p."authorId" = u.id
   GROUP BY u.id
   HAVING COUNT(p.id) > $1`,
  [minPosts]
);

# === SQLAlchemy: text() ===
from sqlalchemy import text
 
stmt = text("""
    SELECT u.*, COUNT(p.id) as post_count
    FROM users u
    LEFT JOIN posts p ON p.author_id = u.id
    GROUP BY u.id
    HAVING COUNT(p.id) > :min_posts
""")
result = session.execute(stmt, {"min_posts": min_posts}).all()
 
# SQLAlchemy: ハイブリッド（Core + ORM）
from sqlalchemy import func, select
 
stmt = (
    select(User, func.count(Post.id).label("post_count"))
    .outerjoin(Post)
    .group_by(User.id)
    .having(func.count(Post.id) > min_posts)
    .order_by(func.count(Post.id).desc())
)
results = session.execute(stmt).all()

// === Drizzle: サブクエリ ===
import { sql, eq, gt, and } from "drizzle-orm";
 
// 各部署の平均給与以上の社員
const deptAvg = db
  .select({
    deptId: employees.departmentId,
    avgSalary: sql`AVG(${employees.salary})`.as("avg_salary"),
  })
  .from(employees)
  .groupBy(employees.departmentId)
  .as("dept_avg");
 
const result = await db
  .select()
  .from(employees)
  .innerJoin(deptAvg, eq(employees.departmentId, deptAvg.deptId))
  .where(gt(employees.salary, deptAvg.avgSalary));
 
// === Prisma: fluent API ===
// Prismaでは複雑なサブクエリは$queryRawが必要
const result = await prisma.$queryRaw`
  SELECT e.*
  FROM employees e
  INNER JOIN (
    SELECT department_id, AVG(salary) as avg_salary
    FROM employees GROUP BY department_id
  ) da ON e.department_id = da.department_id
  WHERE e.salary > da.avg_salary
`;

# === SQLAlchemy: 複雑なサブクエリ ===
from sqlalchemy import select, func
 
# 各部署の平均給与以上の社員
dept_avg = (
    select(
        Employee.department_id,
        func.avg(Employee.salary).label("avg_salary")
    )
    .group_by(Employee.department_id)
    .subquery()
)
 
stmt = (
    select(Employee)
    .join(dept_avg, Employee.department_id == dept_avg.c.department_id)
    .where(Employee.salary > dept_avg.c.avg_salary)
)
results = session.scalars(stmt).all()
 
# SQLAlchemy: ウィンドウ関数
from sqlalchemy import over
 
stmt = (
    select(
        Employee.name,
        Employee.salary,
        func.rank().over(
            partition_by=Employee.department_id,
            order_by=Employee.salary.desc()
        ).label("salary_rank")
    )
)

// NG: 本番でスキーマ自動同期
const dataSource = new DataSource({
  type: "postgres",
  synchronize: true,  // ← 本番で絶対NG！
  // テーブルが自動変更される → データ消失リスク
});
 
// OK: マイグレーションファイルで明示的に管理
const dataSource = new DataSource({
  type: "postgres",
  synchronize: false,
  migrations: ["dist/migrations/*.js"],
  migrationsRun: true,  // 起動時にマイグレーション実行
});

// NG: ループ内で個別クエリ
const users = await prisma.user.findMany();
for (const user of users) {
  // ユーザーごとに1クエリ = N+1問題!
  const posts = await prisma.post.findMany({
    where: { authorId: user.id },
  });
  console.log(`${user.name}: ${posts.length} posts`);
}
 
// OK: include で1回のクエリに統合
const users = await prisma.user.findMany({
  include: {
    posts: {
      select: { id: true },  // 必要なフィールドだけ
    },
  },
});
for (const user of users) {
  console.log(`${user.name}: ${user.posts.length} posts`);
}

# NG: async コンテキストでの遅延ロード（SQLAlchemy 2.0）
async def get_users():
    async with async_session() as session:
        result = await session.execute(select(User))
        users = result.scalars().all()
 
    # セッション外でリレーションアクセス → エラー or N+1
    for user in users:
        print(user.posts)  # DetachedInstanceError or lazy load
 
# OK: 明示的にローディング戦略を指定
async def get_users_with_posts():
    async with async_session() as session:
        result = await session.execute(
            select(User).options(selectinload(User.posts))
        )
        users = result.scalars().all()
        for user in users:
            print(user.posts)  # 既にロード済み

// NG: sql テンプレートで型を無視
const result = await db.execute(sql`SELECT * FROM users WHERE id = ${userId}`);
// result の型は不明確
 
// OK: 型安全なクエリビルダーを使用
const result = await db
  .select()
  .from(users)
  .where(eq(users.id, userId));
// result の型は推論される: { id: string, name: string, ... }[]

# SQLAlchemy: yield_per でメモリ効率的な大量読み取り
stmt = select(User).execution_options(yield_per=1000)
for user in session.scalars(stmt):
    process(user)
# → 1000行ずつDBから取得（全行をメモリに載せない）

// Prisma: カーソルベースのページネーション
let cursor: string | undefined;
while (true) {
  const users = await prisma.user.findMany({
    take: 100,
    ...(cursor ? { skip: 1, cursor: { id: cursor } } : {}),
    orderBy: { id: "asc" },
  });
  if (users.length === 0) break;
  cursor = users[users.length - 1].id;
  for (const user of users) {
    await process(user);
  }
}

// Prisma: RLSとクライアント拡張
const prismaWithTenant = prisma.$extends({
  query: {
    $allModels: {
      async $allOperations({ args, query }) {
        // 全クエリにテナントフィルタを自動追加
        args.where = { ...args.where, tenantId: currentTenantId };
        return query(args);
      },
    },
  },
});

# SQLAlchemy: イベントフックでマルチテナント
from sqlalchemy import event
 
@event.listens_for(Session, "do_orm_execute")
def _add_tenant_filter(execute_state):
    if execute_state.is_select:
        execute_state.statement = execute_state.statement.where(
            User.tenant_id == get_current_tenant_id()
        )

// Prisma: バージョンフィールドで楽観的ロック
const updated = await prisma.product.update({
  where: { id: productId, version: currentVersion },
  data: { name: "New Name", version: { increment: 1 } },
});
// version が一致しない場合は RecordNotFoundError

# SQLAlchemy: version_id_col で楽観的ロック
class Product(Base):
    __tablename__ = "products"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    version: Mapped[int] = mapped_column(default=1)
 
    __mapper_args__ = {
        "version_id_col": version,
    }
 
# 更新時にバージョン不一致でStaleDataError
product = session.get(Product, product_id)
product.name = "New Name"
session.commit()  # UPDATE ... WHERE id = ? AND version = ?

// 問題のあるコード
const departments = await prisma.department.findMany();
for (const dept of departments) {
  const employees = await prisma.employee.findMany({
    where: { departmentId: dept.id },
  });
  const avgSalary = employees.reduce((sum, e) => sum + e.salary, 0) / employees.length;
  console.log(`${dept.name}: avg salary = ${avgSalary}`);
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]