<?xml version="1.0" encoding="utf-8" standalone="yes"?><?xml-stylesheet href="/feed_style.xsl" type="text/xsl"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="https://www.rssboard.org/media-rss"><channel><title>Graphql – El blog de Ignacio</title><link>https://www.igalvan.es/tags/graphql/</link><description>Entradas de Graphql en El blog de Ignacio</description><generator>Hugo -- gohugo.io</generator><language>es</language><copyright>Ignacio Galván Vitas</copyright><lastBuildDate>Fri, 30 Oct 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.igalvan.es/tags/graphql/index.xml" rel="self" type="application/rss+xml"/><icon>https://www.igalvan.es/logo.svg</icon><item><title>El N+1 en el log, DataLoader y lo que pasa con la caché</title><link>https://www.igalvan.es/posts/2026/graphql-n-mas-1-dataloader-cache/</link><pubDate>Fri, 30 Oct 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/graphql-n-mas-1-dataloader-cache/</guid><description><![CDATA[<p>Tercera y última entrada de la serie. En la <a href="/posts/2026/graphql-para-gente-de-rest/">primera</a> está la teoría y en la <a href="/posts/2026/graphql-laboratorio-rest-vs-graphql/">segunda</a> el laboratorio: PostgreSQL con dos tablas, una API REST en FastAPI y una API GraphQL en Strawberry, las dos sobre el mismo <code>db.py</code>, y la base de datos escribiendo en su log cada consulta que recibe.</p>
<p>Allí comparé la ficha de un usuario y GraphQL salía ganando. Ahora cambio la pantalla.</p>
<h2 id="segunda-pantalla-el-listado">Segunda pantalla: el listado <a class="ancla" href="#segunda-pantalla-el-listado" aria-label="Enlace a esta sección">#</a></h2>
<p>El caso de uso: una tabla con cien usuarios, y para cada uno el importe de sus tres últimos pedidos. Es la pantalla de &ldquo;listado con un poco de detalle&rdquo; que tiene cualquier aplicación.</p>
<h3 id="en-rest">En REST <a class="ancla" href="#en-rest" aria-label="Enlace a esta sección">#</a></h3>
<p>En REST, para esta pantalla, no tengo nada. <code>/usuarios/{id}</code> y <code>/usuarios/{id}/pedidos</code> me obligan a hacer una petición para la lista y cien más para los pedidos, lo cual es el N+1 <strong>en HTTP</strong>, que es aún peor que en SQL.</p>
<p>Así que hago lo que hace todo el mundo: un endpoint para la pantalla.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py (añadido)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(
</span></span><span style="display:flex;"><span>    primeros: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">10</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">1</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">100</span>),
</span></span><span style="display:flex;"><span>    pedidos: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">3</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">10</span>),
</span></span><span style="display:flex;"><span>):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT u.id, u.nombre,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                   COALESCE(
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     json_agg(
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       json_build_object(&#39;fecha&#39;, p.fecha, &#39;total&#39;, p.total)
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       ORDER BY p.fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     ) FILTER (WHERE p.id IS NOT NULL),
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     &#39;[]&#39;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                   ) AS pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            FROM usuarios u
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LEFT JOIN LATERAL (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              SELECT * FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              WHERE usuario_id = u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ) p ON true
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            GROUP BY u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (pedidos, primeros),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()</span></span></code></pre></div>
</div>
<p>Una sola consulta. El <code>LATERAL</code> es el truco de PostgreSQL para &ldquo;los N últimos de cada uno&rdquo;, y el <code>json_agg</code> monta la lista de pedidos ya en la base de datos. Es un endpoint muy bueno y muy a medida: devuelve exactamente lo que quiere esta pantalla, y si mañana otra pantalla quiere el <code>estado</code> de los pedidos, hay que tocar el SQL.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -s <span style="color:#e6db74">&#39;localhost:8000/usuarios?primeros=100&amp;pedidos=3&#39;</span> | jq <span style="color:#e6db74">&#39;.[0]&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;id&#34;</span>: 1,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 1&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-06-02&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 44.1 <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2025-11-19&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 173.25 <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2025-03-08&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 12.9 <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Y en el log de PostgreSQL:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT u.id, u.nombre, COALESCE<span style="color:#f92672">(</span>json_agg<span style="color:#f92672">(</span>...<span style="color:#f92672">))</span> AS pedidos FROM usuarios u LEFT JOIN LATERAL <span style="color:#f92672">(</span>...<span style="color:#f92672">)</span> ...</span></span></code></pre></div>
</div>
<p>Una línea.</p>
<h3 id="en-graphql-tal-cual-estaba">En GraphQL, tal cual estaba <a class="ancla" href="#en-graphql-tal-cual-estaba" aria-label="Enlace a esta sección">#</a></h3>
<p>En GraphQL no hay que escribir un endpoint nuevo. Solo necesito una query que devuelva varios usuarios; el campo <code>pedidos</code> ya existe en el tipo <code>Usuario</code>.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py (añadido a Query)</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(self, primeros: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Usuario]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios ORDER BY id LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (primeros,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Usuario(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]</span></span></code></pre></div>
</div>
<p>Y el cliente pide:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -s localhost:8001/graphql <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -H <span style="color:#e6db74">&#39;Content-Type: application/json&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -d <span style="color:#e6db74">&#39;{&#34;query&#34;: &#34;{ usuarios(primeros: 100) { nombre pedidos(ultimos: 3) { total } } }&#34;}&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  | jq <span style="color:#e6db74">&#39;.data.usuarios[0]&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 1&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;44.10&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;173.25&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;12.90&#34;</span> <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Funciona, la respuesta es perfecta, el cliente ha obtenido exactamente lo que quería sin que yo escribiera un endpoint. Ahora el log:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios ORDER BY id LIMIT <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">1</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">2</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">3</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>...
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">100</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~/lab-graphql$ podman compose logs db | grep -c <span style="color:#e6db74">&#39;FROM pedidos WHERE usuario_id&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#ae81ff">100</span></span></span></code></pre></div>
</div>
<p>Ciento una consultas. Esto es el N+1, y conviene entender por qué ha pasado, porque no es un bug: es el diseño de los resolvers funcionando como se espera. <code>Query.usuarios</code> resolvió la lista con una consulta. Después Strawberry recorrió los cien usuarios, y para cada uno, como el cliente había pedido <code>pedidos</code>, llamó a <code>Usuario.pedidos</code>, que hace su consulta con <code>self.id</code>. Cien veces. El resolver de <code>pedidos</code> no sabe que hay otros noventa y nueve como él en marcha; solo sabe resolver los pedidos de un usuario. (Si quieres ver cómo se lee lo que hace PostgreSQL con cada una de esas consultas, tengo <a href="/posts/2026/explain-analyze-para-humanos/">una entrada sobre EXPLAIN ANALYZE</a>.)</p>
<p>En REST esto no me pasó porque <strong>yo</strong> escribí la consulta para la pantalla. En GraphQL la pantalla la ha inventado el cliente, y el servidor la ha resuelto de la única manera que sabía: campo a campo.</p>
<h2 id="dataloader">DataLoader <a class="ancla" href="#dataloader" aria-label="Enlace a esta sección">#</a></h2>
<p>La solución es un patrón, no una librería concreta, aunque Strawberry trae una implementación. La idea: en vez de que <code>Usuario.pedidos</code> haga su consulta en el acto, le pide los pedidos a un <em>loader</em> y se queda esperando. El loader no consulta nada hasta que todos los resolvers de ese ciclo han hecho su petición; entonces junta las cien claves y lanza <strong>una</strong> consulta para todas. Después reparte los resultados a cada resolver que esperaba.</p>
<p>Para que eso funcione los resolvers tienen que ser asíncronos (si no, no hay &ldquo;quedarse esperando&rdquo;), así que <code>Usuario.pedidos</code> pasa a <code>async</code>.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py (versión con DataLoader)</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> datetime
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> decimal
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> strawberry
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.dataloader <span style="color:#f92672">import</span> DataLoader
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.fastapi <span style="color:#f92672">import</span> GraphQLRouter
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Pedido</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    fecha: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>    total: decimal<span style="color:#f92672">.</span>Decimal
</span></span><span style="display:flex;"><span>    estado: str
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">cargar_pedidos</span>(claves: list[tuple[int, int]]) <span style="color:#f92672">-&gt;</span> list[list[Pedido]]:
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;Recibe pares (usuario_id, ultimos) y devuelve, en el mismo orden,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">    la lista de pedidos de cada uno.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    ids <span style="color:#f92672">=</span> [usuario_id <span style="color:#66d9ef">for</span> usuario_id, _ <span style="color:#f92672">in</span> claves]
</span></span><span style="display:flex;"><span>    tope <span style="color:#f92672">=</span> max(ultimos <span style="color:#66d9ef">for</span> _, ultimos <span style="color:#f92672">in</span> claves)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT id, usuario_id, fecha, total, estado
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            FROM (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              SELECT *,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     row_number() OVER (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       PARTITION BY usuario_id ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     ) AS n
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              WHERE usuario_id = ANY(</span><span style="color:#e6db74">%s</span><span style="color:#e6db74">)
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ) t
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            WHERE n &lt;= </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY usuario_id, fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (ids, tope),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    por_usuario: dict[int, list[Pedido]] <span style="color:#f92672">=</span> {}
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas:
</span></span><span style="display:flex;"><span>        uid <span style="color:#f92672">=</span> f<span style="color:#f92672">.</span>pop(<span style="color:#e6db74">&#34;usuario_id&#34;</span>)
</span></span><span style="display:flex;"><span>        por_usuario<span style="color:#f92672">.</span>setdefault(uid, [])<span style="color:#f92672">.</span>append(Pedido(<span style="color:#f92672">**</span>f))
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> [por_usuario<span style="color:#f92672">.</span>get(uid, [])[:ultimos] <span style="color:#66d9ef">for</span> uid, ultimos <span style="color:#f92672">in</span> claves]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Usuario</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    nombre: str
</span></span><span style="display:flex;"><span>    email: str
</span></span><span style="display:flex;"><span>    direccion: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    telefono: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    fecha_alta: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(self, info: strawberry<span style="color:#f92672">.</span>Info, ultimos: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Pedido]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> <span style="color:#66d9ef">await</span> info<span style="color:#f92672">.</span>context[<span style="color:#e6db74">&#34;pedidos&#34;</span>]<span style="color:#f92672">.</span>load((self<span style="color:#f92672">.</span>id, ultimos))
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Query</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(self, id: int) <span style="color:#f92672">-&gt;</span> Usuario <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> Usuario(<span style="color:#f92672">**</span>fila) <span style="color:#66d9ef">if</span> fila <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(self, primeros: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Usuario]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios ORDER BY id LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (primeros,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Usuario(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">contexto</span>():
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> {<span style="color:#e6db74">&#34;pedidos&#34;</span>: DataLoader(load_fn<span style="color:#f92672">=</span>cargar_pedidos)}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>schema <span style="color:#f92672">=</span> strawberry<span style="color:#f92672">.</span>Schema(query<span style="color:#f92672">=</span>Query)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>app<span style="color:#f92672">.</span>include_router(
</span></span><span style="display:flex;"><span>    GraphQLRouter(schema, context_getter<span style="color:#f92672">=</span>contexto), prefix<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;/graphql&#34;</span>
</span></span><span style="display:flex;"><span>)</span></span></code></pre></div>
</div>
<p>Tres cosas que mirar:</p>
<ul>
<li><strong><code>cargar_pedidos</code> recibe una lista de claves y devuelve una lista de resultados en el mismo orden.</strong> Es el contrato de todo DataLoader. La clave es <code>(usuario_id, ultimos)</code> porque el campo tiene un argumento; si fuera solo <code>usuario_id</code>, un cliente que pidiera <code>ultimos: 3</code> para unos y <code>ultimos: 5</code> para otros rompería el agrupado.</li>
<li><strong>La consulta es la del <code>LATERAL</code> de REST, resuelta con una función de ventana.</strong> <code>row_number() OVER (PARTITION BY usuario_id ORDER BY fecha DESC)</code> numera los pedidos de cada usuario del más reciente al más antiguo, y <code>n &lt;= tope</code> se queda con los primeros. <code>ANY(%s)</code> recibe la lista de ids como un array de PostgreSQL; psycopg hace la conversión.</li>
<li><strong>El loader se crea en <code>contexto()</code>, una vez por petición HTTP.</strong> Si fuera global, cachearía resultados entre peticiones y servirías datos viejos. Ese es el error típico al empezar con DataLoader.</li>
</ul>
<p>El cliente no cambia nada. La misma consulta de antes, y el log:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios ORDER BY id LIMIT <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, usuario_id, fecha, total, estado FROM <span style="color:#f92672">(</span>SELECT *, row_number<span style="color:#f92672">()</span> OVER <span style="color:#f92672">(</span>...<span style="color:#f92672">)</span> AS n FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> ANY<span style="color:#f92672">(</span><span style="color:#e6db74">&#39;{1,2,3,...,100}&#39;</span><span style="color:#f92672">))</span> t WHERE n &lt;<span style="color:#f92672">=</span> <span style="color:#ae81ff">3</span> ORDER BY usuario_id, fecha DESC</span></span></code></pre></div>
</div>
<p>Dos consultas. Hemos vuelto al nivel de REST, con una diferencia que vale la pena notar: el endpoint REST servía a <em>esta</em> pantalla, y el loader sirve a cualquier consulta que pase por <code>Usuario.pedidos</code>, venga de donde venga. Es más trabajo la primera vez y menos las siguientes.</p>
<p>Y una pega que no voy a esconder: <code>cargar_pedidos</code> es <code>async</code> pero llama a psycopg en modo síncrono, así que bloquea el bucle de eventos mientras consulta. Para el laboratorio da igual; en un servidor real usarías <code>psycopg.AsyncConnection</code> o un <em>pool</em>. Lo dejo así para que el código sea comparable con el de REST línea a línea.</p>
<h2 id="la-caché-en-treinta-segundos">La caché, en treinta segundos <a class="ancla" href="#la-cach%c3%a9-en-treinta-segundos" aria-label="Enlace a esta sección">#</a></h2>
<p>Lo último que quedaba pendiente de la primera entrada. En REST, el endpoint de un usuario es un <code>GET</code> a una URL, y cachearlo es una cabecera:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py (modificado)</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> Response
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(id: int, response: Response):
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">...</span>
</span></span><span style="display:flex;"><span>    response<span style="color:#f92672">.</span>headers[<span style="color:#e6db74">&#34;Cache-Control&#34;</span>] <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;public, max-age=60&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> fila</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -sI localhost:8000/usuarios/42 | grep -i cache
</span></span><span style="display:flex;"><span>cache-control: public, max-age<span style="color:#f92672">=</span><span style="color:#ae81ff">60</span></span></span></code></pre></div>
</div>
<p>A partir de aquí, cualquier proxy inverso, CDN o navegador que haya por el camino puede servir ese usuario durante un minuto sin preguntar al servidor. No has escrito nada.</p>
<p>En GraphQL, la misma ficha es un <code>POST /graphql</code> con la consulta en el cuerpo. Para un proxy, es una petición opaca e idéntica a todas las demás; no hay URL que identifique el recurso ni método que diga que es una lectura. <code>Cache-Control</code> no sirve de nada, y lo que te queda son las alternativas que mencioné en la primera entrada: consultas persistidas (el cliente manda un identificador por <code>GET</code> en vez de la consulta entera, y entonces sí hay algo cacheable), caché normalizada en el cliente, o caché de respuestas en el propio servidor. Todas funcionan; ninguna viene de serie.</p>
<h2 id="lo-que-ha-enseñado-el-laboratorio">Lo que ha enseñado el laboratorio <a class="ancla" href="#lo-que-ha-ense%c3%b1ado-el-laboratorio" aria-label="Enlace a esta sección">#</a></h2>
<p>Con dos tablas y dos pantallas:</p>
<ul>
<li>Para una ficha, GraphQL gana en HTTP (una petición, respuesta a medida) y empata en la base de datos.</li>
<li>Para un listado, REST gana en la base de datos porque el endpoint lo escribiste tú para esa pantalla; GraphQL pierde de serie (101 consultas) y empata con DataLoader, a cambio de más código en el servidor y de que el patrón se reutilice.</li>
<li>La caché HTTP la tiene REST gratis y GraphQL no la tiene.</li>
</ul>
<p>Nada de esto es nuevo si leíste la primera entrada, pero ahora las frases tienen una línea de log detrás. Y la conclusión sigue siendo la misma: GraphQL no es mejor ni peor que REST; mueve el trabajo de sitio. De escribir endpoints a escribir loaders, de la caché HTTP a la caché de aplicación, de decidir tú la forma de los datos a defenderte de la forma que decida el cliente. Si ese cambio te conviene, adelante. Si no, REST sigue estando muy bien.</p>
<p>El código de las tres entradas está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql</a>.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_8d929e04e945a9b.png"/></item><item><title>Un laboratorio para comparar REST y GraphQL con los mismos datos</title><link>https://www.igalvan.es/posts/2026/graphql-laboratorio-rest-vs-graphql/</link><pubDate>Thu, 29 Oct 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/graphql-laboratorio-rest-vs-graphql/</guid><description><![CDATA[<p>En la <a href="/posts/2026/graphql-para-gente-de-rest/">entrada anterior</a> conté la teoría. Ahora toca verla. Voy a montar una base de datos pequeña, exponer los mismos datos con una API REST y con una API GraphQL, y comparar lo que pide el cliente, lo que recibe y lo que le llega a PostgreSQL por detrás.</p>
<p>Esta entrada es el montaje y la primera comparación, la amable. En la siguiente viene el N+1, que es donde se pone interesante.</p>
<p>El código completo está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql</a>.</p>
<h2 id="los-datos">Los datos <a class="ancla" href="#los-datos" aria-label="Enlace a esta sección">#</a></h2>
<p>Dos tablas: usuarios y pedidos. Nada más, porque con dos tablas ya se ven todos los problemas que quiero enseñar.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#75715e">-- init.sql
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">TABLE</span> usuarios (
</span></span><span style="display:flex;"><span>  id         serial <span style="color:#66d9ef">PRIMARY</span> <span style="color:#66d9ef">KEY</span>,
</span></span><span style="display:flex;"><span>  nombre     text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  email      text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  direccion  text,
</span></span><span style="display:flex;"><span>  telefono   text,
</span></span><span style="display:flex;"><span>  fecha_alta date <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">TABLE</span> pedidos (
</span></span><span style="display:flex;"><span>  id         serial <span style="color:#66d9ef">PRIMARY</span> <span style="color:#66d9ef">KEY</span>,
</span></span><span style="display:flex;"><span>  usuario_id int <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span> <span style="color:#66d9ef">REFERENCES</span> usuarios(id),
</span></span><span style="display:flex;"><span>  fecha      date <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  total      numeric(<span style="color:#ae81ff">10</span>,<span style="color:#ae81ff">2</span>) <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  estado     text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">INSERT</span> <span style="color:#66d9ef">INTO</span> usuarios (nombre, email, direccion, telefono, fecha_alta)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;Usuario &#39;</span> <span style="color:#f92672">||</span> i,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;usuario&#39;</span> <span style="color:#f92672">||</span> i <span style="color:#f92672">||</span> <span style="color:#e6db74">&#39;@example.org&#39;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;Calle Mayor, &#39;</span> <span style="color:#f92672">||</span> i,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;600&#39;</span> <span style="color:#f92672">||</span> lpad(i::text, <span style="color:#ae81ff">6</span>, <span style="color:#e6db74">&#39;0&#39;</span>),
</span></span><span style="display:flex;"><span>  date <span style="color:#e6db74">&#39;2024-01-01&#39;</span> <span style="color:#f92672">+</span> i <span style="color:#f92672">*</span> <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">FROM</span> generate_series(<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">100</span>) <span style="color:#66d9ef">AS</span> i;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">INSERT</span> <span style="color:#66d9ef">INTO</span> pedidos (usuario_id, fecha, total, estado)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span>
</span></span><span style="display:flex;"><span>  <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">99</span>)::int,
</span></span><span style="display:flex;"><span>  date <span style="color:#e6db74">&#39;2025-01-01&#39;</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">600</span>)::int,
</span></span><span style="display:flex;"><span>  round((<span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">200</span>)::numeric, <span style="color:#ae81ff">2</span>),
</span></span><span style="display:flex;"><span>  (ARRAY[<span style="color:#e6db74">&#39;pendiente&#39;</span>, <span style="color:#e6db74">&#39;enviado&#39;</span>, <span style="color:#e6db74">&#39;entregado&#39;</span>])[<span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>)::int]
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">FROM</span> generate_series(<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">500</span>);</span></span></code></pre></div>
</div>
<p>Cien usuarios y quinientos pedidos repartidos al azar. Los usuarios tienen seis columnas a propósito: la gracia del over-fetching es que haya cosas que sobren.</p>
<h2 id="postgresql-en-podman">PostgreSQL en Podman <a class="ancla" href="#postgresql-en-podman" aria-label="Enlace a esta sección">#</a></h2>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#75715e"># compose.yaml</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">services</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">db</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">image</span>: <span style="color:#ae81ff">docker.io/library/postgres:17</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">environment</span>:
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_USER</span>: <span style="color:#ae81ff">lab</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_PASSWORD</span>: <span style="color:#ae81ff">lab</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_DB</span>: <span style="color:#ae81ff">tienda</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">ports</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;5432:5432&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">volumes</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#ae81ff">./init.sql:/docker-entrypoint-initdb.d/init.sql:Z</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">command</span>: [<span style="color:#e6db74">&#34;postgres&#34;</span>, <span style="color:#e6db74">&#34;-c&#34;</span>, <span style="color:#e6db74">&#34;log_statement=all&#34;</span>]</span></span></code></pre></div>
</div>
<p>Dos detalles. El <code>:Z</code> del volumen es para que SELinux deje al contenedor leer el fichero; si no usas SELinux, no estorba. Y <code>log_statement=all</code> hace que PostgreSQL escriba en su log <strong>todas</strong> las consultas que recibe. En producción es una barbaridad; aquí es el instrumento de medida de toda la serie.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose up -d
</span></span><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose logs db | tail -n <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>db  | 2026-10-27 18:02:11.431 UTC <span style="color:#f92672">[</span>1<span style="color:#f92672">]</span> LOG:  database system is ready to accept connections</span></span></code></pre></div>
</div>
<p>Si en algún momento quieres empezar de cero, <code>podman compose down -v</code> borra también el volumen de datos y el <code>init.sql</code> se vuelve a ejecutar al arrancar.</p>
<h2 id="el-acceso-a-datos-compartido">El acceso a datos, compartido <a class="ancla" href="#el-acceso-a-datos-compartido" aria-label="Enlace a esta sección">#</a></h2>
<p>Las dos APIs van a usar exactamente el mismo módulo para hablar con la base de datos. Si no, la comparación está trucada.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># db.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> psycopg
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> psycopg.rows <span style="color:#f92672">import</span> dict_row
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>DSN <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;postgresql://lab:lab@localhost:5432/tienda&#34;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">conectar</span>():
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> psycopg<span style="color:#f92672">.</span>connect(DSN, row_factory<span style="color:#f92672">=</span>dict_row)</span></span></code></pre></div>
</div>
<p><code>dict_row</code> hace que cada fila venga como un diccionario con el nombre de las columnas, que es lo que FastAPI y Strawberry quieren recibir.</p>
<p>La estructura del repositorio queda así:</p>
<div class="codeblock"><pre tabindex="0"><code>lab-graphql/
├── compose.yaml
├── init.sql
├── db.py
├── api_rest/
│   └── main.py
└── api_graphql/
    └── main.py</code></pre>
</div>
<p>Un aviso que me costó un rato: la carpeta del servidor GraphQL <strong>no</strong> puede llamarse <code>graphql</code>. Strawberry depende de una librería que se llama exactamente así, y un directorio con ese nombre en el directorio de trabajo la tapa. De ahí el <code>api_graphql</code>.</p>
<p>Dependencias, en un entorno virtual:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ python3 -m venv .venv <span style="color:#f92672">&amp;&amp;</span> source .venv/bin/activate
</span></span><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ pip install fastapi <span style="color:#e6db74">&#34;uvicorn[standard]&#34;</span> <span style="color:#e6db74">&#34;psycopg[binary]&#34;</span> strawberry-graphql</span></span></code></pre></div>
</div>
<h2 id="la-api-rest">La API REST <a class="ancla" href="#la-api-rest" aria-label="Enlace a esta sección">#</a></h2>
<p>Dos endpoints, los dos de la entrada anterior. FastAPI porque es lo que menos ruido mete.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI, HTTPException, Query
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(id: int):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> fila <span style="color:#f92672">is</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">raise</span> HTTPException(<span style="color:#ae81ff">404</span>, <span style="color:#e6db74">&#34;Usuario no encontrado&#34;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> fila
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">/pedidos&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(id: int, ultimos: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">10</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">1</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">100</span>)):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT * FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            WHERE usuario_id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (id, ultimos),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()</span></span></code></pre></div>
</div>
<p><code>/usuarios/42</code> devuelve el usuario entero, con sus seis campos, porque así es como se diseñan los endpoints REST: el servidor decide la forma. <code>/usuarios/42/pedidos?ultimos=3</code> devuelve los pedidos enteros, cuatro campos cada uno.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ uvicorn api_rest.main:app --port <span style="color:#ae81ff">8000</span></span></span></code></pre></div>
</div>
<h2 id="la-api-graphql">La API GraphQL <a class="ancla" href="#la-api-graphql" aria-label="Enlace a esta sección">#</a></h2>
<p>Strawberry define el esquema con clases de Python y anotaciones de tipo. Compáralo con el SDL de la entrada anterior: es lo mismo, escrito en otro sitio.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> datetime
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> decimal
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> strawberry
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.fastapi <span style="color:#f92672">import</span> GraphQLRouter
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Pedido</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    fecha: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>    total: decimal<span style="color:#f92672">.</span>Decimal
</span></span><span style="display:flex;"><span>    estado: str
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Usuario</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    nombre: str
</span></span><span style="display:flex;"><span>    email: str
</span></span><span style="display:flex;"><span>    direccion: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    telefono: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    fecha_alta: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(self, ultimos: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Pedido]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                SELECT id, fecha, total, estado FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                WHERE usuario_id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>                (self<span style="color:#f92672">.</span>id, ultimos),
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Pedido(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Query</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(self, id: int) <span style="color:#f92672">-&gt;</span> Usuario <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> Usuario(<span style="color:#f92672">**</span>fila) <span style="color:#66d9ef">if</span> fila <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>schema <span style="color:#f92672">=</span> strawberry<span style="color:#f92672">.</span>Schema(query<span style="color:#f92672">=</span>Query)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>app<span style="color:#f92672">.</span>include_router(GraphQLRouter(schema), prefix<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;/graphql&#34;</span>)</span></span></code></pre></div>
</div>
<p>Fíjate en dónde está cada consulta SQL. <code>Query.usuario</code> es un resolver: va a por el usuario. <code>Usuario.pedidos</code> es <strong>otro</strong> resolver, que se ejecuta solo si el cliente pide el campo <code>pedidos</code>, y que va a por los pedidos de ese usuario concreto (<code>self.id</code>). Los campos simples (<code>nombre</code>, <code>email</code>…) no tienen resolver: Strawberry los lee directamente del objeto.</p>
<p>Esto es exactamente la estructura que en la entrada anterior llamé &ldquo;un controlador por campo&rdquo;. Guárdate la imagen para la siguiente entrada.</p>
<p>Dos cosas de Strawberry que conviene saber: convierte los nombres a <em>camelCase</em> en el esquema, así que <code>fecha_alta</code> se pide como <code>fechaAlta</code>; y los tipos <code>date</code> y <code>Decimal</code> de Python los expone como escalares <code>Date</code> y <code>Decimal</code> sin que haya que hacer nada.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ uvicorn api_graphql.main:app --port <span style="color:#ae81ff">8001</span></span></span></code></pre></div>
</div>
<p>Con el servidor levantado, <code>http://localhost:8001/graphql</code> en el navegador abre GraphiQL, una consola para escribir consultas con autocompletado contra el esquema. Es lo que en REST sería el Swagger UI de FastAPI (<code>http://localhost:8000/docs</code>), con la diferencia de que aquí el autocompletado sale del esquema real, no de una descripción paralela.</p>
<h2 id="primera-pantalla-la-ficha-de-un-usuario">Primera pantalla: la ficha de un usuario <a class="ancla" href="#primera-pantalla-la-ficha-de-un-usuario" aria-label="Enlace a esta sección">#</a></h2>
<p>El caso de uso: una pantalla que muestra el nombre de un usuario y la fecha e importe de sus tres últimos pedidos. Nada más.</p>
<h3 id="en-rest">En REST <a class="ancla" href="#en-rest" aria-label="Enlace a esta sección">#</a></h3>
<p>Dos peticiones, porque son dos recursos:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~$ curl -s localhost:8000/usuarios/42 | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;id&#34;</span>: 42,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 42&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;email&#34;</span>: <span style="color:#e6db74">&#34;usuario42@example.org&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;direccion&#34;</span>: <span style="color:#e6db74">&#34;Calle Mayor, 42&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;telefono&#34;</span>: <span style="color:#e6db74">&#34;600000042&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;fecha_alta&#34;</span>: <span style="color:#e6db74">&#34;2024-05-06&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>ignacio@milab:~$ curl -s <span style="color:#e6db74">&#39;localhost:8000/usuarios/42/pedidos?ultimos=3&#39;</span> | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;id&#34;</span>: 317,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;usuario_id&#34;</span>: 42,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-07-14&#34;</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;total&#34;</span>: 118.4,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;estado&#34;</span>: <span style="color:#e6db74">&#34;entregado&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span><span style="color:#f92672">]</span></span></span></code></pre></div>
</div>
<p>De los seis campos del usuario, la pantalla usa uno. De los cinco de cada pedido, dos. Y el <code>usuario_id</code> de cada pedido es información que el cliente ya tenía: lo puso él en la URL.</p>
<h3 id="en-graphql">En GraphQL <a class="ancla" href="#en-graphql" aria-label="Enlace a esta sección">#</a></h3>
<p>Una petición, y el cliente escribe la forma de la respuesta:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~$ curl -s localhost:8001/graphql <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -H <span style="color:#e6db74">&#39;Content-Type: application/json&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -d <span style="color:#e6db74">&#39;{&#34;query&#34;: &#34;{ usuario(id: 42) { nombre pedidos(ultimos: 3) { fecha total } } }&#34;}&#39;</span> | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;data&#34;</span>: <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;usuario&#34;</span>: <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>      <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 42&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-07-14&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;118.40&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>        ...
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Ni un campo de más. Si mañana la pantalla necesita también el <code>estado</code>, el cliente lo añade a la consulta y ya está; nadie toca el servidor.</p>
<p>Si quieres medir el tamaño, es un <code>wc -c</code> al final de cada <code>curl</code>. Los números exactos dependen de los datos que haya generado el <code>random()</code>, pero la proporción es la que esperas: la respuesta GraphQL ocupa bastante menos de la mitad que las dos respuestas REST juntas.</p>
<h2 id="lo-que-ve-postgresql">Lo que ve PostgreSQL <a class="ancla" href="#lo-que-ve-postgresql" aria-label="Enlace a esta sección">#</a></h2>
<p>Aquí es donde el <code>log_statement=all</code> empieza a pagar el alquiler. Deja el log abierto en otra terminal:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose logs -f db</span></span></code></pre></div>
</div>
<p>Lanza las dos peticiones REST:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios WHERE id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT * FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<p>Y ahora la de GraphQL:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios WHERE id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<p>Dos consultas en los dos casos. Para esta pantalla, lo único que cambia entre REST y GraphQL es la capa HTTP: una petición en vez de dos, y una respuesta a medida en vez de dos respuestas genéricas. La base de datos trabaja lo mismo.</p>
<p>(Si en el log ves <code>execute &lt;unnamed&gt;</code> en lugar de <code>statement</code>, es porque psycopg puede usar sentencias preparadas del lado del servidor; da igual para lo que estamos midiendo.)</p>
<h2 id="dónde-estamos">Dónde estamos <a class="ancla" href="#d%c3%b3nde-estamos" aria-label="Enlace a esta sección">#</a></h2>
<p>Hasta aquí GraphQL parece ganar sin despeinarse: menos peticiones, menos bytes, el cliente manda. Y para esta pantalla es verdad.</p>
<p>El problema es que la pantalla era de un usuario. En la <a href="/posts/2026/graphql-n-mas-1-dataloader-cache/">tercera entrada</a> pido cien usuarios con sus pedidos, con el mismo log abierto, y el resultado es bastante menos elegante.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_d7c5d2b15b24bf51.png"/></item><item><title>GraphQL explicado a alguien que lleva años haciendo REST</title><link>https://www.igalvan.es/posts/2026/graphql-para-gente-de-rest/</link><pubDate>Tue, 27 Oct 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/graphql-para-gente-de-rest/</guid><description><![CDATA[<p>Llevo muchos años consumiendo y diseñando APIs REST. Suficientes como para que GraphQL me pareciera, durante bastante tiempo, una moda de frontends. Esta entrada es lo que me habría gustado leer entonces: sin evangelizar, con las pegas delante, y partiendo de lo que ya sé de REST.</p>
<p>Es la primera de una serie de tres. Esta es la teoría; en las dos siguientes monto un laboratorio con PostgreSQL y expongo los mismos datos por REST y por GraphQL para ver con un log delante todo lo que aquí cuento de palabra.</p>
<h2 id="el-cambio-de-mentalidad-en-una-frase">El cambio de mentalidad en una frase <a class="ancla" href="#el-cambio-de-mentalidad-en-una-frase" aria-label="Enlace a esta sección">#</a></h2>
<p>En REST el servidor decide la forma de la respuesta. En GraphQL la decide el cliente.</p>
<p>Eso es todo. El resto son consecuencias.</p>
<p>En REST expones recursos (<code>/usuarios/42</code>, <code>/usuarios/42/pedidos</code>) y cada uno devuelve lo que tú decidiste que devuelve. Si el cliente necesita el nombre del usuario y la fecha de sus tres últimos pedidos, hace dos peticiones y se trae de paso veinte campos que no quería. Si eso duele, acabas creando <code>/usuarios/42?fields=nombre</code> o, peor, <code>/pantalla-inicio-movil</code>, un endpoint hecho a medida de una pantalla concreta. Todos lo hemos hecho.</p>
<p>GraphQL ataca exactamente ese problema. Hay un único endpoint (normalmente <code>POST /graphql</code>) y el cliente manda una descripción de lo que quiere:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-graphql" data-lang="graphql"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  usuario(id: <span style="color:#a6e22e">42</span>) {
</span></span><span style="display:flex;"><span>    nombre
</span></span><span style="display:flex;"><span>    pedidos(ultimos: <span style="color:#a6e22e">3</span>) {
</span></span><span style="display:flex;"><span>      fecha
</span></span><span style="display:flex;"><span>      total
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}</span></span></code></pre></div>
</div>
<p>Y recibe exactamente eso, con la misma forma:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;data&#34;</span>: {
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&#34;usuario&#34;</span>: {
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Ignacio&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;pedidos&#34;</span>: [
</span></span><span style="display:flex;"><span>        { <span style="color:#f92672">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-10-20&#34;</span>, <span style="color:#f92672">&#34;total&#34;</span>: <span style="color:#ae81ff">31.5</span> },
</span></span><span style="display:flex;"><span>        { <span style="color:#f92672">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-10-12&#34;</span>, <span style="color:#f92672">&#34;total&#34;</span>: <span style="color:#ae81ff">8.0</span> },
</span></span><span style="display:flex;"><span>        { <span style="color:#f92672">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-09-30&#34;</span>, <span style="color:#f92672">&#34;total&#34;</span>: <span style="color:#ae81ff">120.0</span> }
</span></span><span style="display:flex;"><span>      ]
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}</span></span></code></pre></div>
</div>
<p>Una petición, ni un byte de más, y el cliente puede cambiar lo que pide sin que nadie toque el servidor.</p>
<h2 id="las-piezas-traducidas-a-vocabulario-rest">Las piezas, traducidas a vocabulario REST <a class="ancla" href="#las-piezas-traducidas-a-vocabulario-rest" aria-label="Enlace a esta sección">#</a></h2>
<p><strong>El esquema (schema).</strong> Es el contrato, y es obligatorio. Si en REST te apoyas en OpenAPI, aquí el esquema no es documentación: es lo que el servidor valida contra cada petición. Se escribe en un lenguaje propio (SDL) y está tipado:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-graphql" data-lang="graphql"><span style="display:flex;"><span><span style="color:#66d9ef">type</span> <span style="color:#a6e22e">Usuario</span> {
</span></span><span style="display:flex;"><span>  id: <span style="color:#a6e22e">ID</span>!
</span></span><span style="display:flex;"><span>  nombre: <span style="color:#a6e22e">String</span>!
</span></span><span style="display:flex;"><span>  email: <span style="color:#a6e22e">String</span>
</span></span><span style="display:flex;"><span>  pedidos(ultimos: <span style="color:#a6e22e">Int</span> = 10): [<span style="color:#a6e22e">Pedido</span>!]!
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">type</span> <span style="color:#a6e22e">Pedido</span> {
</span></span><span style="display:flex;"><span>  id: <span style="color:#a6e22e">ID</span>!
</span></span><span style="display:flex;"><span>  fecha: <span style="color:#a6e22e">String</span>!
</span></span><span style="display:flex;"><span>  total: <span style="color:#a6e22e">Float</span>!
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">type</span> <span style="color:#a6e22e">Query</span> {
</span></span><span style="display:flex;"><span>  usuario(id: <span style="color:#a6e22e">ID</span>!): <span style="color:#a6e22e">Usuario</span>
</span></span><span style="display:flex;"><span>}</span></span></code></pre></div>
</div>
<p>El <code>!</code> significa &ldquo;no nulo&rdquo;. <code>[Pedido!]!</code> es una lista no nula de pedidos no nulos. Esta precisión sobre la nulabilidad es una de las cosas que más echo de menos cuando vuelvo a JSON &ldquo;a pelo&rdquo;.</p>
<p><strong>Query y Mutation.</strong> Las queries son tus <code>GET</code>: leer. Las mutations son tus <code>POST</code>/<code>PUT</code>/<code>DELETE</code>: todo lo que escribe. GraphQL no distingue entre crear y modificar; eso lo defines tú en el nombre (<code>crearPedido</code>, <code>cancelarPedido</code>). Hay un tercer tipo, <code>Subscription</code>, para recibir datos en tiempo real, normalmente sobre WebSocket; lo dejo fuera de aquí.</p>
<p><strong>Resolvers.</strong> Es donde vive el código. Cada campo del esquema tiene (o hereda) una función que sabe obtener su valor. <code>Query.usuario</code> va a la base de datos a por el usuario; <code>Usuario.pedidos</code> va a por los pedidos <em>de ese usuario</em>. El servidor recorre la petición del cliente campo a campo llamando al resolver que toque.</p>
<p>Si vienes de REST esto se parece a tener un controlador por campo en vez de uno por endpoint. Y es la fuente del problema más famoso de GraphQL, que viene ahora.</p>
<h2 id="lo-que-se-pierde-y-nadie-te-cuenta-en-la-demo">Lo que se pierde (y nadie te cuenta en la demo) <a class="ancla" href="#lo-que-se-pierde-y-nadie-te-cuenta-en-la-demo" aria-label="Enlace a esta sección">#</a></h2>
<h3 id="la-caché-http">La caché HTTP <a class="ancla" href="#la-cach%c3%a9-http" aria-label="Enlace a esta sección">#</a></h3>
<p>En REST, <code>GET /usuarios/42</code> es cacheable por cualquier intermediario que entienda HTTP: navegador, CDN, proxy inverso. Es gratis y es enorme.</p>
<p>En GraphQL todo va por <code>POST</code> al mismo endpoint, con la consulta en el cuerpo. Para un proxy, todas las peticiones son iguales y ninguna es cacheable. Las soluciones existen (consultas persistidas con <code>GET</code>, caché normalizada en el cliente, caché de respuestas en el servidor), pero hay que montarlas y ninguna es tan simple como un <code>Cache-Control</code>.</p>
<h3 id="el-problema-n1">El problema N+1 <a class="ancla" href="#el-problema-n1" aria-label="Enlace a esta sección">#</a></h3>
<p>Vuelve a mirar la consulta del principio. El resolver de <code>usuario</code> hace una consulta SQL. Después, para <code>pedidos</code>, otra. Bien. Ahora imagina esta:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-graphql" data-lang="graphql"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  usuarios(primeros: <span style="color:#a6e22e">100</span>) {
</span></span><span style="display:flex;"><span>    nombre
</span></span><span style="display:flex;"><span>    pedidos(ultimos: <span style="color:#a6e22e">3</span>) { total }
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}</span></span></code></pre></div>
</div>
<p>Un resolver ingenuo hace una consulta para los 100 usuarios y luego <strong>100 consultas más</strong>, una por usuario, para sus pedidos. 101 viajes a la base de datos para algo que en SQL se resuelve con un <code>JOIN</code> y un <code>LIMIT</code> por ventana.</p>
<p>La solución estándar se llama <em>DataLoader</em> y consiste en agrupar: en lugar de resolver los pedidos usuario a usuario, el servidor acumula los 100 ids y lanza una sola consulta <code>WHERE usuario_id IN (...)</code>. Funciona, pero es una capa más que tienes que escribir y entender. En REST el N+1 también existe, pero lo ves venir porque tú escribiste el endpoint; en GraphQL lo provoca el cliente con una consulta que tú nunca anticipaste.</p>
<h3 id="el-código-de-estado-es-siempre-200">El código de estado es siempre 200 <a class="ancla" href="#el-c%c3%b3digo-de-estado-es-siempre-200" aria-label="Enlace a esta sección">#</a></h3>
<p>Una petición GraphQL con errores devuelve, casi siempre, <code>200 OK</code> con un bloque <code>errors</code> en el JSON:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;data&#34;</span>: { <span style="color:#f92672">&#34;usuario&#34;</span>: <span style="color:#66d9ef">null</span> },
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;errors&#34;</span>: [
</span></span><span style="display:flex;"><span>    { <span style="color:#f92672">&#34;message&#34;</span>: <span style="color:#e6db74">&#34;Usuario no encontrado&#34;</span>, <span style="color:#f92672">&#34;path&#34;</span>: [<span style="color:#e6db74">&#34;usuario&#34;</span>] }
</span></span><span style="display:flex;"><span>  ]
</span></span><span style="display:flex;"><span>}</span></span></code></pre></div>
</div>
<p>Además, los errores son parciales: puede venir la mitad de los datos y errores en la otra mitad. Esto desmonta cualquier monitorización que cuentes por códigos HTTP, y los clientes tienen que mirar siempre <code>errors</code>, no solo el estado.</p>
<h3 id="no-hay-recurso-al-que-apuntar">No hay &ldquo;recurso&rdquo; al que apuntar <a class="ancla" href="#no-hay-recurso-al-que-apuntar" aria-label="Enlace a esta sección">#</a></h3>
<p>En REST, la URL identifica al recurso. Sirve para enlazar, para registrar en logs, para permisos por ruta, para rate limiting por endpoint. En GraphQL nada de eso aplica tal cual: la autorización pasa a ser por tipo o por campo, el rate limiting por <em>coste</em> de la consulta, y los logs tienen que registrar la consulta entera para servir de algo.</p>
<h3 id="el-cliente-puede-pedir-demasiado">El cliente puede pedir demasiado <a class="ancla" href="#el-cliente-puede-pedir-demasiado" aria-label="Enlace a esta sección">#</a></h3>
<p>Si tu esquema tiene relaciones circulares (usuario → pedidos → usuario → pedidos…), un cliente malintencionado o simplemente torpe puede pedir una consulta de profundidad 50 y tumbarte el servidor. Hay que poner límites de profundidad y de complejidad, y desactivar la introspección (la capacidad de preguntarle al servidor por su propio esquema) en producción si la API no es pública. En REST este problema no existe porque el servidor acota lo que devuelve cada endpoint.</p>
<h2 id="lo-que-se-gana-de-verdad">Lo que se gana (de verdad) <a class="ancla" href="#lo-que-se-gana-de-verdad" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li><strong>Un esquema vivo y tipado.</strong> Las herramientas (GraphiQL, generadores de clientes) se construyen sobre él. Autocompletado real contra la API, clientes generados con tipos correctos, documentación que no se desactualiza porque <em>es</em> el contrato.</li>
<li><strong>Evolución sin versiones.</strong> Añades campos y nadie se entera; marcas los viejos como <code>@deprecated</code> y puedes medir quién los sigue usando porque el servidor ve exactamente qué campos pide cada cliente. El <code>/v2/</code> desaparece.</li>
<li><strong>Agregación de fuentes.</strong> Un esquema puede resolver <code>usuario</code> contra una base de datos y <code>usuario.saldo</code> contra otro servicio. El cliente ve un grafo; el servidor esconde la fontanería. Esto es lo que antes hacía el <em>backend for frontend</em>, pero sin escribir uno por pantalla.</li>
<li><strong>Varios clientes distintos sobre la misma API.</strong> Web, móvil, un panel interno: cada uno pide lo suyo. Este es el caso de uso original (Facebook, 2012) y sigue siendo el más sólido.</li>
</ul>
<h2 id="cuándo-no-merece-la-pena">Cuándo no merece la pena <a class="ancla" href="#cu%c3%a1ndo-no-merece-la-pena" aria-label="Enlace a esta sección">#</a></h2>
<p>Mi lista, sin pretensiones:</p>
<ul>
<li>Una API interna sencilla con dos o tres consumidores que controlas tú. REST, y a otra cosa.</li>
<li>Integración máquina a máquina con operaciones fijas (&ldquo;envíame este fichero&rdquo;, &ldquo;dame el estado de esta transacción&rdquo;). No hay nada que el cliente necesite moldear.</li>
<li>Cuando la caché HTTP es lo que te salva la vida: contenido público, muy leído, poco cambiante.</li>
<li>Cuando el equipo no va a tener tiempo de montar DataLoader, límites de complejidad y autorización por campo. GraphQL sin eso es una API REST peor, con un agujero de rendimiento y seguridad.</li>
<li>Si lo que de verdad quieres es &ldquo;dame solo estos campos&rdquo;, bastante gente resuelve eso con un parámetro <code>fields</code> en REST y duerme tranquila.</li>
</ul>
<h2 id="cuándo-sí">Cuándo sí <a class="ancla" href="#cu%c3%a1ndo-s%c3%ad" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li>Varios clientes con necesidades distintas sobre los mismos datos.</li>
<li>Datos muy relacionados, donde la pantalla típica cruza cuatro o cinco entidades.</li>
<li>Una capa de agregación delante de servicios heterogéneos.</li>
<li>Equipos de frontend que avanzan más rápido que los de backend y necesitan dejar de pedir endpoints.</li>
</ul>
<h2 id="resumen-para-quien-no-haya-bajado-hasta-aquí">Resumen para quien no haya bajado hasta aquí <a class="ancla" href="#resumen-para-quien-no-haya-bajado-hasta-aqu%c3%ad" aria-label="Enlace a esta sección">#</a></h2>
<p>GraphQL no sustituye a REST; cambia quién manda sobre la forma de la respuesta. A cambio de flexibilidad para el cliente, pagas con la caché HTTP, con el N+1, con errores que no son errores HTTP y con una superficie de ataque que tienes que acotar a mano. Si esos cuatro problemas tienen nombre en tu cabeza antes de empezar, GraphQL puede ser una muy buena herramienta. Si no, probablemente no la necesitas todavía.</p>
<h2 id="lo-que-viene">Lo que viene <a class="ancla" href="#lo-que-viene" aria-label="Enlace a esta sección">#</a></h2>
<p>En la <a href="/posts/2026/graphql-laboratorio-rest-vs-graphql/">segunda entrada</a> monto el laboratorio: PostgreSQL en Podman, una API REST y una API GraphQL en Python sobre las mismas dos tablas, y la primera pantalla comparada. En la <a href="/posts/2026/graphql-n-mas-1-dataloader-cache/">tercera</a> pido cien usuarios de golpe, enseño el N+1 en el log de la base de datos, lo arreglo con DataLoader y cierro con la caché. Que es donde todo esto se entiende de verdad.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_a0df0b547810cc66.png"/></item></channel></rss>