Gestion des Réponses HTTP avec Nexy

Nexy, construit sur FastAPI, offre une gestion avancée des réponses HTTP. Il permet d'utiliser toutes les réponses standard de FastAPI tout en ajoutant des fonctionnalités supplémentaires via le décorateur @HTTPResponse. Ce décorateur simplifie la personnalisation des réponses en encapsulant la logique de réponse dans une fonction unique.

Introduction aux Réponses HTTP

Les réponses HTTP sont essentielles pour la communication entre le client et le serveur. Elles permettent de transmettre des données, des statuts et des en-têtes. Nexy hérite de la flexibilité de FastAPI tout en introduisant des simplifications pour une gestion plus intuitive des réponses.

Utilisation de la Classe Response

La classe Response de Nexy étend celle de FastAPI, permettant une personnalisation facile des réponses :

python

from nexy import Response

def GET():
    return Response(
        content={"message": "Hello World"},
        status_code=200,
        headers={"X-Custom-Header": "value"}
    )

Réponses Standard de FastAPI

Nexy supporte toutes les réponses standard de FastAPI, telles que JSONResponse, HTMLResponse, et plus encore :

python

from fastapi.responses import (
    JSONResponse,
    HTMLResponse, 
    PlainTextResponse,
    RedirectResponse,
    StreamingResponse,
    FileResponse
)

Personnalisation des Réponses avec HTTPResponse

Le décorateur @HTTPResponse de Nexy permet de personnaliser les réponses de manière élégante et efficace. Il encapsule la logique de réponse et offre une flexibilité accrue.

python

from nexy import HTTPResponse
from typing import Any

class CustomJSONResponse(Response):
    media_type = "application/json"
    
    def render(self, content: Any) -> bytes:
        # Logique de rendu personnalisée
        data = {
			"data": content, 
			"timestamp": datetime.now().isoformat()
		}
        return json.dumps(data).encode("utf-8")

@HTTPResponse(type=CustomJSONResponse)
def GET():
    return {"message": "Hello"}

HTMLResponse avec et sans Décorateur

Avec Décorateur

Utiliser le décorateur @HTTPResponse pour enrichir votre endpoint avec une validation et une documentation automatiques :

python

from nexy import HTTPResponse
from fastapi.responses import HTMLResponse

@HTTPResponse(
    type=HTMLResponse,
    response_map={
        200: {"description": "Page HTML réussie"},
        404: {"description": "Template non trouvé"}
    }
)
def GET():
    return """
        <html>
            <body>
                <h1>Bienvenue</h1>
            </body>
        </html>
    """

Avantages du décorateur :

Documentation OpenAPI/Swagger automatique
Validation stricte du type de contenu
Gestion standardisée des erreurs
Meilleure maintenabilité du code

Sans Décorateur

Approche directe pour des cas simples :

python

from fastapi.responses import HTMLResponse

def GET():
    html_content = """
        <html>
            <body>
                <h1>Bienvenue</h1>
            </body>
        </html>
    """
    return HTMLResponse(
        content=html_content,
        status_code=200
    )

JSONResponse avec et sans Décorateur

La réponse JSON est le format privilégié pour les API RESTful. Nexy facilite sa manipulation grâce à l'intégration native de Pydantic.

Avec Décorateur

python

from nexy import HTTPResponse
from pydantic import BaseModel, EmailStr

class UserModel(BaseModel):
    id: int
    name: str
    email: EmailStr

@HTTPResponse(
    model=UserModel,
    model_exclude={"password"},
    model_by_alias=True,
    response_map={
        200: {"description": "Utilisateur trouvé"},
        404: {"description": "Utilisateur non trouvé"}
    }
)
def GET(user_id: int):
    return {
        "id": user_id,
        "name": "John Doe",
        "email": "john@example.com"
    }

Sans Décorateur

python

from fastapi.responses import JSONResponse

def GET(user_id: int):
    user_data = {
        "id": user_id,
        "name": "Espoir Loém",
        "email": "espoir@example.com"
    }
    return JSONResponse(
        content=user_data,
        status_code=200
    )

StreamingResponse avec et sans Décorateur

Avec Décorateur

python

from nexy import HTTPResponse
from fastapi.responses import StreamingResponse

@HTTPResponse(
    type=StreamingResponse,
    response_map={
        200: {"description": "Flux de données"},
        503: {"description": "Service indisponible"}
    }
)
async def GET():
    async def generate():
        for i in range(10):
            yield f"data: {i}\n\n"
            await asyncio.sleep(1)
    
    return generate()

Sans Décorateur

python

from fastapi.responses import StreamingResponse

async def GET():
    async def generate():
        for i in range(10):
            yield f"data: {i}\n\n"
            await asyncio.sleep(1)
    
    return StreamingResponse(
        generate(),
        media_type="text/event-stream"
    )

Gestion des Erreurs

Nexy fournit des réponses d'erreur standardisées :

python

from nexy import HTTPException, Response

def GET(item_id: int):
    if not item_exists(item_id):
        raise HTTPException(
            status_code=404,
            detail="Item non trouvé",
            headers={"X-Error-Code": "ITEM_NOT_FOUND"}
        )
    return Response(content=get_item(item_id))

Meilleures Pratiques pour les Réponses HTTP

Lors de la conception de vos API avec Nexy, gardez à l'esprit les meilleures pratiques suivantes :

Utilisez des codes de statut HTTP appropriés pour indiquer le résultat de l'opération.
Fournissez des messages d'erreur clairs et concis pour aider les développeurs à comprendre les problèmes.
Utilisez des en-têtes HTTP pour transmettre des métadonnées importantes.
Assurez-vous que vos réponses sont sécurisées et ne divulguent pas d'informations sensibles.

← Controllers Composants →