feat: Implement TodoList CRUD API with in-memory storage

Build a complete RESTful API for managing todo lists using FastAPI with full type hints and modern Python patterns.

Architecture:
- Clean separation of concerns (models, routers, services)
- Dependency injection for service layer
- In-memory storage using Python lists (data resets on restart)
- Async/await patterns throughout

Core components:
- app/models.py: Pydantic v2 models for validation
  * TodoListBase - Base model with name field
  * TodoListCreate - DTO for creating todos
  * TodoListUpdate - DTO for updating todos
  * TodoList - Complete model with ID

- app/services/todo_lists.py: Business logic service
  * TodoListService class with in-memory storage
  * CRUD operations: all(), get(), create(), update(), delete()
  * Singleton pattern via get_todo_list_service()

- app/routers/todo_lists.py: API endpoints
  * GET /api/todolists - List all todos
  * GET /api/todolists/{id} - Get single todo
  * POST /api/todolists - Create new todo
  * PUT /api/todolists/{id} - Update todo
  * DELETE /api/todolists/{id} - Delete todo
  * Proper HTTP status codes (200, 201, 204, 404)
  * HTTPException handling for not found cases

- app/main.py: FastAPI application setup
  * Application metadata (title, description, version)
  * Router registration
  * Health check endpoint at /

Features:
- Full type hints compatible with Python 3.9+
- Automatic API documentation at /docs and /redoc
- Request/response validation via Pydantic
- RESTful resource naming and HTTP verbs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: cguarinosu

app/__init__.py

@@ -0,0 +1 @@
+"""FastAPI Todo List application."""

app/main.py

@@ -0,0 +1,28 @@
+"""FastAPI application entry point."""
+
+from typing import Dict
+
+from fastapi import FastAPI
+
+from app.routers import todo_lists
+
+# Create FastAPI application instance
+app = FastAPI(
+    title="TodoList API",
+    description="A simple Todo List API for Python/FastAPI candidates",
+    version="1.0.0",
+)
+
+# Include routers
+app.include_router(todo_lists.router)
+
+
+@app.get("/", tags=["health"])
+async def root() -> Dict[str, str]:
+    """
+    Health check endpoint.
+
+    Returns:
+        Simple message indicating the API is running
+    """
+    return {"message": "TodoList API is running"}

app/models.py

@@ -0,0 +1,29 @@
+"""Pydantic models for TodoList API."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class TodoListBase(BaseModel):
+    """Base TodoList model with common attributes."""
+
+    name: str = Field(..., min_length=1, description="Name of the todo list")
+
+
+class TodoListCreate(TodoListBase):
+    """Model for creating a new TodoList."""
+
+    pass
+
+
+class TodoListUpdate(TodoListBase):
+    """Model for updating an existing TodoList."""
+
+    pass
+
+
+class TodoList(TodoListBase):
+    """TodoList model with all attributes including ID."""
+
+    id: int = Field(..., description="Unique identifier for the todo list")
+
+    model_config = ConfigDict(from_attributes=True)

app/routers/__init__.py

@@ -0,0 +1 @@
+"""API routers."""

app/routers/todo_lists.py

@@ -0,0 +1,120 @@
+"""TodoList API router with CRUD endpoints."""
+
+from typing import Annotated, List
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from app.models import TodoList, TodoListCreate, TodoListUpdate
+from app.services.todo_lists import TodoListService, get_todo_list_service
+
+router = APIRouter(prefix="/api/todolists", tags=["todolists"])
+
+
+@router.get("", response_model=List[TodoList], status_code=status.HTTP_200_OK)
+async def index(
+    service: Annotated[TodoListService, Depends(get_todo_list_service)],
+) -> List[TodoList]:
+    """
+    Get all todo lists.
+
+    Returns:
+        List of all TodoList objects
+    """
+    return service.all()
+
+
+@router.get("/{todo_list_id}", response_model=TodoList, status_code=status.HTTP_200_OK)
+async def show(
+    todo_list_id: int,
+    service: Annotated[TodoListService, Depends(get_todo_list_service)],
+) -> TodoList:
+    """
+    Get a specific todo list by ID.
+
+    Args:
+        todo_list_id: The ID of the todo list to retrieve
+        service: Injected TodoListService instance
+
+    Returns:
+        TodoList object
+
+    Raises:
+        HTTPException: 404 if todo list not found
+    """
+    todo_list = service.get(todo_list_id)
+    if todo_list is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TodoList with id {todo_list_id} not found",
+        )
+    return todo_list
+
+
+@router.post("", response_model=TodoList, status_code=status.HTTP_201_CREATED)
+async def create(
+    todo_list_data: TodoListCreate,
+    service: Annotated[TodoListService, Depends(get_todo_list_service)],
+) -> TodoList:
+    """
+    Create a new todo list.
+
+    Args:
+        todo_list_data: Data for creating the todo list
+        service: Injected TodoListService instance
+
+    Returns:
+        The newly created TodoList object
+    """
+    return service.create(todo_list_data)
+
+
+@router.put("/{todo_list_id}", response_model=TodoList, status_code=status.HTTP_200_OK)
+async def update(
+    todo_list_id: int,
+    todo_list_data: TodoListUpdate,
+    service: Annotated[TodoListService, Depends(get_todo_list_service)],
+) -> TodoList:
+    """
+    Update an existing todo list.
+
+    Args:
+        todo_list_id: The ID of the todo list to update
+        todo_list_data: New data for the todo list
+        service: Injected TodoListService instance
+
+    Returns:
+        Updated TodoList object
+
+    Raises:
+        HTTPException: 404 if todo list not found
+    """
+    updated_todo_list = service.update(todo_list_id, todo_list_data)
+    if updated_todo_list is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TodoList with id {todo_list_id} not found",
+        )
+    return updated_todo_list
+
+
+@router.delete("/{todo_list_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete(
+    todo_list_id: int,
+    service: Annotated[TodoListService, Depends(get_todo_list_service)],
+) -> None:
+    """
+    Delete a todo list by ID.
+
+    Args:
+        todo_list_id: The ID of the todo list to delete
+        service: Injected TodoListService instance
+
+    Raises:
+        HTTPException: 404 if todo list not found
+    """
+    deleted = service.delete(todo_list_id)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"TodoList with id {todo_list_id} not found",
+        )

app/services/__init__.py

@@ -0,0 +1 @@
+"""Business logic services."""

app/services/todo_lists.py

@@ -0,0 +1,106 @@
+"""TodoList service with in-memory storage."""
+
+from typing import List, Optional
+
+from app.models import TodoList, TodoListCreate, TodoListUpdate
+
+
+class TodoListService:
+    """Service for managing TodoLists with in-memory storage."""
+
+    def __init__(self) -> None:
+        """Initialize the service with empty storage."""
+        self._storage: List[TodoList] = []
+        self._next_id: int = 1
+
+    def all(self) -> List[TodoList]:
+        """
+        Get all todo lists.
+
+        Returns:
+            List of all TodoList objects
+        """
+        return self._storage.copy()
+
+    def get(self, todo_list_id: int) -> Optional[TodoList]:
+        """
+        Get a specific todo list by ID.
+
+        Args:
+            todo_list_id: The ID of the todo list to retrieve
+
+        Returns:
+            TodoList object if found, None otherwise
+        """
+        for todo_list in self._storage:
+            if todo_list.id == todo_list_id:
+                return todo_list
+        return None
+
+    def create(self, todo_list_data: TodoListCreate) -> TodoList:
+        """
+        Create a new todo list.
+
+        Args:
+            todo_list_data: Data for creating the todo list
+
+        Returns:
+            The newly created TodoList object
+        """
+        new_todo_list = TodoList(id=self._next_id, name=todo_list_data.name)
+        self._storage.append(new_todo_list)
+        self._next_id += 1
+        return new_todo_list
+
+    def update(self, todo_list_id: int, todo_list_data: TodoListUpdate) -> Optional[TodoList]:
+        """
+        Update an existing todo list.
+
+        Args:
+            todo_list_id: The ID of the todo list to update
+            todo_list_data: New data for the todo list
+
+        Returns:
+            Updated TodoList object if found, None otherwise
+        """
+        for i, todo_list in enumerate(self._storage):
+            if todo_list.id == todo_list_id:
+                updated_todo_list = TodoList(id=todo_list_id, name=todo_list_data.name)
+                self._storage[i] = updated_todo_list
+                return updated_todo_list
+        return None
+
+    def delete(self, todo_list_id: int) -> bool:
+        """
+        Delete a todo list by ID.
+
+        Args:
+            todo_list_id: The ID of the todo list to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        for i, todo_list in enumerate(self._storage):
+            if todo_list.id == todo_list_id:
+                self._storage.pop(i)
+                return True
+        return False
+
+
+# Global singleton instance
+_todo_list_service: Optional[TodoListService] = None
+
+
+def get_todo_list_service() -> TodoListService:
+    """
+    Get or create the singleton TodoListService instance.
+
+    This function is used for dependency injection in FastAPI.
+
+    Returns:
+        The singleton TodoListService instance
+    """
+    global _todo_list_service
+    if _todo_list_service is None:
+        _todo_list_service = TodoListService()
+    return _todo_list_service