v0.1.3

Full Changelog: v0.1.2...v0.1.3

v0.1.2

Full Changelog: v0.1.1...v0.1.2

v0.1.1

[0.1.1] - 2025-10-03

Fixed

• Type Validation Improvements: Resolved TypeAdapter compatibility issues when using the @throttle decorator with complex Query Parameter extraction scenarios
• Query Parameter Handling: Enhanced robustness for nested and multi-type query parameter processing in rate limiting contexts
• Decorator Stability: Improved error handling and type coercion for edge cases in parameter-based key extraction strategies

Full Changelog: v0.1.0...v0.1.1

v0.1.0

🚀 Fastrict v0.1.0 - Advanced Fallback Key Extraction

The most powerful FastAPI rate limiter just got smarter!

We're excited to announce Fastrict v0.1.0, featuring revolutionary fallback key extraction strategies that bring enterprise-grade flexibility to your rate limiting needs.

✨ Major New Features

🎯 Middleware Default Key Extraction

Set a default key extraction strategy for your entire application that applies to all routes unless overridden.

# Create intelligent fallback strategy for middleware
default_strategy = create_api_key_fallback(
    api_key_header="X-API-Key",
    auth_header="Authorization"
    # Automatically falls back to IP if headers are missing
)

app.add_middleware(
    RateLimitMiddleware,
    rate_limit_use_case=rate_limiter,
    default_key_extraction=default_strategy  # 🆕 NEW!
)

🔄 Intelligent Fallback Key Extraction

Try multiple extraction methods in sequence until one succeeds - perfect for real-world authentication scenarios.

# Try API key → Auth header → IP address (in that order)
@app.get("/api/data")
@throttle(
    limit=100, ttl=3600,
    key_extraction_strategy=create_api_key_fallback()  # 🆕 NEW!
)
async def protected_endpoint():
    return {"data": "intelligently rate limited"}

🛠️ Pre-built Helper Functions

Get started instantly with production-ready fallback patterns:

• create_auth_header_fallback() - Authorization header → IP
• create_api_key_fallback() - API key → Auth header → IP
• create_user_id_fallback() - User ID param → header → IP

🎨 Enhanced Decorator Support

Pass complete KeyExtractionStrategy objects directly to the @throttle decorator:

@throttle(
    limit=50, ttl=600,
    key_extraction_strategy=custom_fallback_strategy  # 🆕 NEW!
)
async def my_endpoint():
    return {"data": "advanced rate limiting"}

🏗️ Technical Enhancements

🔧 New Enum Value

• Added KeyExtractionType.FALLBACK for sequential extraction strategies

📊 Enhanced Data Models

• KeyExtractionStrategy now supports fallback_strategies field for nested fallback logic

🎯 Smart Priority System

1. Route-specific config (highest priority)
2. Middleware default strategy
3. IP address fallback (always works)

🔄 Backward Compatibility

• All existing code continues to work without changes
• Default behavior preserved when no strategy is specified
• Existing middleware and decorator parameters function as before

🎯 Real-World Use Cases

🏢 Multi-Tenant SaaS

# Perfect for tenant isolation with graceful fallbacks
middleware_strategy = create_api_key_fallback()
app.add_middleware(
    RateLimitMiddleware,
    rate_limit_use_case=rate_limiter,
    default_key_extraction=middleware_strategy
)

🔐 Authentication APIs

# Handle authenticated and anonymous users intelligently
@app.post("/api/secure")
@throttle(
    limit=100, ttl=3600,
    key_extraction_strategy=create_auth_header_fallback()
)
async def secure_endpoint():
    return {"data": "authenticated or IP-based limiting"}

📱 Mobile Applications

# Graceful degradation for mobile apps with inconsistent headers
@app.get("/api/mobile-data")
@throttle(
    limit=200, ttl=3600,
    key_extraction_strategy=create_user_id_fallback()
)
async def mobile_api():
    return {"data": "mobile-optimized rate limiting"}

📊 Performance

Fastrict v0.1.0 maintains our exceptional performance standards:

• ⚡ 0.37ms average response time
• 🚀 3,600+ RPS concurrent throughput
• 🎯 100% success rate under load
• 🛡️ 100% rate limiting accuracy

🔄 Migration Guide

For Existing Users

No action required! v0.1.0 is fully backward compatible. Your existing rate limiting configurations will continue to work exactly as before.

To Use New Features

Simply add the new parameters when ready:

# Before (still works)
app.add_middleware(
    RateLimitMiddleware,
    rate_limit_use_case=rate_limiter
)

# After (enhanced)
app.add_middleware(
    RateLimitMiddleware,
    rate_limit_use_case=rate_limiter,
    default_key_extraction=create_api_key_fallback()  # Add when ready
)

📦 Installation

# Install the latest version
pip install fastrict==0.1.0

# Or upgrade from previous version
pip install --upgrade fastrict

🔗 Links & Resources

• 📖 Full Documentation - Complete usage guide
• 🎯 Fallback Examples - Real-world implementations
• 🐛 Issue Tracker - Bug reports & feature requests
• 💬 Discussions - Community Q&A

🙏 Acknowledgments

Special thanks to our community for the feedback and feature requests that shaped this release. Your real-world use cases drive our development priorities!

🚀 What's Next?

Stay tuned for upcoming features:

• 🌐 GraphQL support
• 📊 Prometheus metrics
• 🔄 Circuit breaker integration
• 🎯 Rate limit warming

---

Happy rate limiting! 🎉

The Fastrict Team

---

📋 Full Changelog

Added:

• Middleware Default Key Extraction via default_key_extraction parameter
• Fallback Key Extraction with KeyExtractionType.FALLBACK
• Helper functions: create_auth_header_fallback(), create_api_key_fallback(), create_user_id_fallback()
• Enhanced decorator with key_extraction_strategy parameter
• Flexible priority system: Route-specific > Middleware default > IP fallback

Enhanced:

• Key extraction logic supports complex fallback scenarios
• Middleware can set default extraction strategy for all routes
• Decorator supports complete KeyExtractionStrategy objects
• Comprehensive documentation with fallback examples

Fixed:

• No breaking changes - fully backward compatible

v0.0.3

🚀 Fastrict - Enterprise FastAPI Rate Limiter

The most powerful, flexible, and production-ready rate limiting system for FastAPI applications.

Fastrict provides enterprise-grade rate limiting with Redis and in-memory backends, supporting everything from simple API throttling to complex multi-tenant rate limiting strategies.

📦 Installation

# Install from PyPI
pip install fastrict

# Install with development dependencies
pip install fastrict[dev]

# Install with documentation dependencies
pip install fastrict[docs]

🔧 System Requirements

Component	Version	Purpose
Python	3.8+	Core runtime
FastAPI	0.68+	Web framework
Redis	4.0+	Primary storage backend
Pydantic	1.8+	Data validation
Starlette	0.14+	ASGI framework

🚀 Quick Start

🎯 1. Basic Setup (30 seconds)

from fastapi import FastAPI
from fastrict import RateLimitMiddleware, RedisRateLimitRepository
from fastrict import RateLimitUseCase, KeyExtractionUseCase

# Create FastAPI app
app = FastAPI(title="My Rate Limited API")

# Setup rate limiting (Redis)
repository = RedisRateLimitRepository.from_url("redis://localhost:6379")
key_extraction = KeyExtractionUseCase()
rate_limiter = RateLimitUseCase(repository, key_extraction)

# Add global rate limiting middleware
app.add_middleware(
    RateLimitMiddleware,
    rate_limit_use_case=rate_limiter,
    excluded_paths=["/health", "/docs", "/metrics"]
)

@app.get("/api/data")
async def get_data():
    return {"message": "This endpoint is globally rate limited"}

📚 Resources & Documentation

📖 Documentation

• API Reference - Complete API documentation
• User Guide - Step-by-step tutorials
• Examples - Real-world examples
• Architecture - Design decisions

🆘 Support Channels

• 🐛 Issue Tracker - Bug reports & feature requests
• 💬 Discussions - Community Q&A
• 📧 Email - Direct support for enterprise users
• 💼 LinkedIn - Professional inquiries

🔗 Related Projects

• FastAPI - Modern, fast web framework for building APIs
• Redis - In-memory data structure store
• Starlette - Lightweight ASGI framework
• Pydantic - Data validation using Python type hints