FastAPI ReactJS Full Stack Course React Clients on Async Python APIs

This chapter focuses on What FastAPI is and why it is fast, ASGI against WSGI, Uvicorn and the server layer and the practice needed to use these concepts confidently in real projects.

• What FastAPI is and why it is fast
• ASGI against WSGI
• Uvicorn and the server layer
• Installing and creating a first app
• The FastAPI application object
• Running with reload in development
• Path operation decorators
• GET, POST, PUT, PATCH and DELETE
• Returning dictionaries and models
• Automatic JSON serialisation
• Interactive docs at /docs
• The ReDoc interface
• The generated OpenAPI schema
• Path parameters and their types
• Type conversion and validation
• Query parameters
• Optional and default query values
• Request bodies
• Combining path, query and body
• Status codes for responses
• Basic error responses
• Project structure for a small API

This chapter focuses on Pydantic v2 fundamentals, Defining a BaseModel, Field types and defaults and the practice needed to use these concepts confidently in real projects.

• Pydantic v2 fundamentals
• Defining a BaseModel
• Field types and defaults
• The Field function and constraints
• String, number and collection constraints
• Optional fields and None handling
• Nested models
• Lists and dictionaries of models
• Model configuration
• Aliases and population by name
• Field validators
• Model validators
• Computed fields
• Custom types and annotated types
• Enums in models
• Datetime and UUID handling
• Strict against lax validation
• Serialisation and model_dump
• Excluding and including fields
• Response models
• Separate input and output models
• Settings management with pydantic-settings

This chapter focuses on The Request object, Reading headers, Cookies in requests and responses and the practice needed to use these concepts confidently in real projects.

• The Request object
• Reading headers
• Cookies in requests and responses
• Form data handling
• File uploads
• Multiple file uploads
• Streaming uploads
• Response classes
• JSONResponse and custom encoders
• HTMLResponse and PlainTextResponse
• FileResponse and downloads
• StreamingResponse
• Redirects
• Setting response headers
• Custom status codes per operation
• APIRouter and modular routing
• Router prefixes and tags
• Router-level dependencies
• Including routers in the app
• Path operation metadata
• Deprecating endpoints
• API versioning approaches

This chapter focuses on What dependencies solve, The Depends function, Function dependencies and the practice needed to use these concepts confidently in real projects.

• What dependencies solve
• The Depends function
• Function dependencies
• Class dependencies
• Sub-dependencies
• Dependency caching per request
• Dependencies with yield
• Cleanup after the response
• Path operation dependencies
• Router and application dependencies
• Parameterised dependencies
• Dependencies for pagination
• Dependencies for common query filters
• Database session dependencies
• Current user dependencies
• Permission checking dependencies
• Dependency overrides in tests
• Global dependencies
• Async dependencies
• Error handling inside dependencies
• Testing dependencies in isolation
• Designing a clean dependency graph

This chapter focuses on Async path operations, When def is better than async def, The thread pool for blocking calls and the practice needed to use these concepts confidently in real projects.

• Async path operations
• When def is better than async def
• The thread pool for blocking calls
• Avoiding blocking the event loop
• Async HTTP clients
• Concurrent calls with gather
• Timeouts on outbound calls
• Middleware in FastAPI
• Writing custom middleware
• CORS middleware configuration
• GZip and compression middleware
• Trusted host middleware
• Request timing middleware
• Correlation id middleware
• Background tasks
• When background tasks are not enough
• Task queues with Celery or ARQ
• Scheduled jobs
• Lifespan events on startup and shutdown
• Sharing resources across requests
• WebSocket endpoints
• Server-sent events

This chapter focuses on Choosing a database layer, SQLAlchemy 2.0 basics, Declarative models and the practice needed to use these concepts confidently in real projects.

• Choosing a database layer
• SQLAlchemy 2.0 basics
• Declarative models
• The engine and sessions
• Session lifecycle per request
• Async SQLAlchemy
• Querying with select
• Filtering, ordering and limits
• Relationships and loading strategies
• Avoiding lazy loading surprises
• Transactions and commits
• Alembic migrations
• Autogenerating migrations
• Seeding data
• SQLModel as an alternative
• Repository patterns
• Separating ORM models from schemas
• Pagination implementations
• Soft deletes and audit columns
• Connection pooling configuration
• Handling database errors
• Testing with a real database

This chapter focuses on Security schemes in OpenAPI, HTTP basic authentication, API key authentication and the practice needed to use these concepts confidently in real projects.

• Security schemes in OpenAPI
• HTTP basic authentication
• API key authentication
• OAuth2 password flow
• The token endpoint
• Password hashing
• Creating and signing JWTs
• Decoding and verifying tokens
• Token expiry and refresh
• The current user dependency
• Scopes and fine-grained permissions
• Role-based authorisation
• Resource ownership checks
• Third-party OAuth providers
• Session cookies for browser clients
• CSRF considerations
• Rate limiting
• Input sanitisation
• Secrets and configuration
• HTTPS and deployment security
• Security headers
• A security review checklist

This chapter focuses on HTTPException and its use, Custom exception classes, Exception handlers and the practice needed to use these concepts confidently in real projects.

• HTTPException and its use
• Custom exception classes
• Exception handlers
• Overriding validation error responses
• Consistent error response schemas
• Problem details format
• Mapping domain errors to HTTP
• Hiding internal details
• Logging configuration in Python
• Structured JSON logging
• Request and response logging
• Correlation ids across services
• Log levels in production
• Redacting sensitive fields
• Health and readiness endpoints
• Prometheus metrics
• OpenTelemetry tracing
• Error tracking integration
• Alerting on error rates
• Debugging production issues
• Reproducing failures locally
• Observability checklist

This chapter focuses on The TestClient, Async test clients, Testing GET endpoints and the practice needed to use these concepts confidently in real projects.

• The TestClient
• Async test clients
• Testing GET endpoints
• Testing POST and validation
• Testing authentication
• Dependency overrides for tests
• Test database setup and teardown
• Fixtures for common data
• Factories for test objects
• Mocking external services
• Testing background tasks
• Testing WebSockets
• Parametrised endpoint tests
• Coverage and meaningful assertions
• Contract testing
• Customising the OpenAPI schema
• Examples in the documentation
• Tags, summaries and descriptions
• Documenting error responses
• Generating client SDKs
• Keeping docs accurate
• Continuous integration setup

This chapter focuses on Benchmarking endpoints, Profiling slow requests, Database query optimisation and the practice needed to use these concepts confidently in real projects.

• Benchmarking endpoints
• Profiling slow requests
• Database query optimisation
• Caching responses
• Redis as a cache layer
• Cache invalidation
• Response compression
• Pagination for large results
• Streaming large payloads
• Worker processes and concurrency
• Gunicorn with Uvicorn workers
• Choosing worker counts
• Dockerising a FastAPI app
• Multi-stage builds
• Environment configuration
• Running migrations on deploy
• Reverse proxy configuration
• Zero-downtime deployment
• Project: designing the API and models
• Project: implementing auth and resources
• Project: tests, docs and hardening
• Project: deployment and final review