# Cache au niveau du resolver, avec clé dépendant des arguments (comme n'importe quel cache applicatif)
import strawberry
from functools import lru_cache
import hashlib, json

async def cache_resolver(cle: str, ttl: int, calcul):
    valeur = await redis.get(cle)
    if valeur is not None:
        return json.loads(valeur)
    resultat = await calcul()
    await redis.set(cle, json.dumps(resultat), ex=ttl)
    return resultat

@strawberry.type
class Query:
    @strawberry.field
    async def produits_populaires(self, categorie_id: strawberry.ID) -> list[Produit]:
        cle = f"produits_populaires:{categorie_id}"
        return await cache_resolver(cle, ttl=300, calcul=lambda: db.produits_populaires(categorie_id))

# Persisted queries : le client envoie un hash au lieu du texte complet de la requête
# -> réduit la bande passante et permet une allowlist stricte des requêtes autorisées en prod

// Automatic Persisted Queries (Apollo) : le client envoie d'abord le hash, puis le texte si inconnu
import { createPersistedQueryLink } from '@apollo/client/link/persisted-queries';
import { sha256 } from 'crypto-hash';

const persistedQueriesLink = createPersistedQueryLink({ sha256 });
const client = new ApolloClient({
  link: persistedQueriesLink.concat(httpLink),
  cache: new InMemoryCache(),
});

# Response caching HTTP : GraphQL utilise POST par défaut donc pas de cache CDN natif
# Solution : GET pour les requêtes persistées + en-têtes cache-control par champ
import strawberry
from strawberry.extensions import Extension

class CacheControlExtension(Extension):
    def on_execute(self):
        yield
        # Chaque type peut déclarer son propre TTL de cache, le plus restrictif l'emporte
        max_age = min(
            (t.get("cacheControl", {}).get("maxAge", 0) for t in self.execution_context.result.data.values()),
            default=0,
        )
        self.execution_context.context["response"].headers["Cache-Control"] = f"public, max-age={max_age}"

# Batching de requêtes HTTP : regrouper plusieurs opérations GraphQL en un seul aller-retour réseau
# (distinct du DataLoader, qui batch des RESOLVERS, ici on batch des REQUÊTES clientes)
import strawberry

@strawberry.type
class Query:
    @strawberry.field
    async def produit(self, id: strawberry.ID) -> Produit: ...

# Le endpoint accepte un tableau d'opérations dans le corps de la requête POST
# [{ "query": "...", "variables": {...} }, { "query": "...", "variables": {...} }]
# et retourne un tableau de réponses correspondant, exécutées en parallèle côté serveur

Checklist performance niveau expert :
| Levier                     | Effet                                                    |
|------------------------------|-------------------------------------------------------------|
| DataLoader                    | élimine le N+1 au niveau resolver                            |
| Cache Redis par resolver      | évite de recalculer des agrégations coûteuses                |
| Persisted queries              | réduit la bande passante, permet une allowlist stricte        |
| Limitation profondeur/coût     | protège contre les requêtes pathologiques                     |
| Tracing (Apollo/OpenTelemetry) | identifie précisément quel resolver ralentit une requête      |