# FastAPI (Python) — REST done right in 2026
from fastapi import FastAPI, HTTPException, Query
from pydantic import BaseModel, Field
from typing import Annotated

app = FastAPI(
    title="User API",
    version="2.0.0",
    openapi_url="/api/openapi.json"
)

class UserResponse(BaseModel):
    id: str
    email: str
    name: str
    created_at: str
    
    class Config:
        json_schema_extra = {
            "example": {
                "id": "usr_123",
                "email": "alice@example.com",
                "name": "Alice",
                "created_at": "2026-01-15T10:30:00Z"
            }
        }

@app.get(
    "/users/{user_id}",
    response_model=UserResponse,
    responses={
        404: {"description": "User not found"},
        429: {"description": "Rate limit exceeded"}
    }
)
async def get_user(
    user_id: str,
    include_details: Annotated[bool, Query(description="Include extended profile")] = False
):
    user = await user_service.find_by_id(user_id)
    if not user:
        raise HTTPException(status_code=404, detail=f"User {user_id} not found")
    return user

@app.get("/users")
async def list_users(
    cursor: str | None = None,
    limit: int = 20,
    sort: Literal["created_at", "name"] = "created_at"
) -> dict:
    users, next_cursor = await user_service.paginate(
        cursor=cursor,
        limit=min(limit, 100),  # cap at 100
        sort=sort
    )
    return {
        "data": users,
        "pagination": {
            "cursor": next_cursor,
            "has_more": next_cursor is not None
        }
    }

import strawberry
from strawberry.types import Info
from strawberry.dataloader import DataLoader

@strawberry.type
class User:
    id: str
    name: str
    email: str
    
    @strawberry.field
    async def orders(self, info: Info) -> list["Order"]:
        # DataLoader batches N+1 queries automatically
        return await info.context.order_loader.load(self.id)

@strawberry.type
class Order:
    id: str
    total: float
    status: str

@strawberry.type
class Query:
    @strawberry.field
    async def user(self, id: str) -> User | None:
        return await user_service.find_by_id(id)
    
    @strawberry.field
    async def users(
        self,
        after: str | None = None,
        first: int = 20,
        filter: "UserFilter | None" = None
    ) -> "UserConnection":
        return await user_service.paginate(after=after, first=first, filter=filter)

schema = strawberry.Schema(query=Query)

# Without DataLoader: N+1 queries
# Fetching 100 users would make 101 DB queries (1 for users + 100 for orders)

# With DataLoader: batched
async def load_orders_batch(user_ids: list[str]) -> list[list[Order]]:
    # Single query for all users' orders
    all_orders = await db.fetch(
        "SELECT * FROM orders WHERE user_id = ANY($1)",
        user_ids
    )
    # Group by user_id
    orders_by_user = {}
    for order in all_orders:
        orders_by_user.setdefault(order.user_id, []).append(order)
    return [orders_by_user.get(uid, []) for uid in user_ids]

# In context per request
context.order_loader = DataLoader(load_fn=load_orders_batch)

# Depth limiting (prevent deeply nested queries)
from strawberry.extensions import MaxTokensLimiter

schema = strawberry.Schema(
    query=Query,
    extensions=[
        MaxTokensLimiter(max_token_count=1000),
    ]
)

# Query complexity analysis
def get_complexity(query: str) -> int:
    # Estimate based on field depth and list fields
    # Reject queries over budget
    pass

import grpc
from concurrent import futures
from generated import user_pb2, user_pb2_grpc

class UserServicer(user_pb2_grpc.UserServiceServicer):
    
    async def GetUser(self, request, context):
        user = await user_repo.find_by_id(request.user_id)
        if not user:
            context.set_code(grpc.StatusCode.NOT_FOUND)
            context.set_details(f"User {request.user_id} not found")
            return user_pb2.GetUserResponse()
        
        return user_pb2.GetUserResponse(
            user=user_pb2.User(
                id=user.id,
                email=user.email,
                name=user.name
            )
        )
    
    async def ListUsers(self, request, context):
        # Server-side streaming
        async for user in user_repo.stream_all():
            yield user_pb2.User(
                id=user.id,
                email=user.email,
                name=user.name
            )

async def serve():
    server = grpc.aio.server(
        futures.ThreadPoolExecutor(max_workers=10),
        options=[
            ('grpc.max_receive_message_length', 10 * 1024 * 1024),
        ]
    )
    user_pb2_grpc.add_UserServiceServicer_to_server(UserServicer(), server)
    server.add_insecure_port('[::]:50051')
    await server.start()
    await server.wait_for_termination()