0Pricing
FastAPI Backend Development Bootcamp · Lección

Definición de tipos, consultas y mutaciones

Construya un esquema GraphQL tipado con Strawberry y móntelo en una aplicación FastAPI con dependencias compartidas.

Definición de tipos, consultas y mutaciones es una lección gratuita de FastAPI Backend Development Bootcamp en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de FastAPI Backend Development Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Why Strawberry for GraphQL on FastAPI

Strawberry is a code-first GraphQL library for Python that uses dataclasses and type hints to define your schema. Instead of writing GraphQL SDL by hand, you write plain Python classes and Strawberry derives the schema from them.

  • Code-first: the Python types ARE the source of truth — the SDL is generated.
  • Type-safe: standard type hints (int, str, list[str], Optional) map directly to GraphQL types.
  • ASGI-native: ships a router that mounts cleanly on a FastAPI app, sharing its event loop and dependency system.

In this lesson we build a typed schema (types, a Query, and a Mutation) and mount it on FastAPI with shared dependencies.

Defining an Object Type

A GraphQL object type is just a class decorated with @strawberry.type. Each annotated attribute becomes a field. Type hints determine the GraphQL field type: int becomes Int, str becomes String, and a non-optional field becomes non-null (!).

  • Use strawberry.ID for identifier fields — it serializes as a string but signals identity semantics.
  • Optional[...] (or X | None) makes a field nullable.
import strawberry
from typing import Optional


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str
    pages: int
    summary: Optional[str] = None

The Query Root Type

Every GraphQL schema needs a Query root — the entry point for reads. You declare it as a @strawberry.type whose fields are resolved by methods decorated with @strawberry.field.

  • The method's return annotation defines the field's GraphQL type.
  • Method parameters (other than self) become GraphQL arguments.
  • Returning a list[Book] produces a non-null list of non-null books: [Book!]!.
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return [
            Book(id="1", title="Dune", author="Herbert", pages=412),
            Book(id="2", title="1984", author="Orwell", pages=328),
        ]

    @strawberry.field
    def book(self, id: strawberry.ID) -> Book | None:
        for b in self.books():
            if b.id == id:
                return b
        return None

Building the Schema

strawberry.Schema ties root types together. At minimum you pass query=Query; later you add mutation=Mutation. Building the schema validates your types and lets you print the generated SDL — a great sanity check.

Here is a fully standalone example: define a type, a query, build the schema, and execute a query synchronously with schema.execute_sync. No server or framework needed.

import strawberry


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return [Book(id="1", title="Dune", author="Herbert")]


schema = strawberry.Schema(query=Query)

result = schema.execute_sync("{ books { id title author } }")
print(result.errors)
print(result.data)

Field Arguments and Defaults

GraphQL arguments come straight from resolver parameters. A parameter with a default value becomes an optional argument; without a default it is required.

  • Use typing.Optional + a default to express a nullable, optional argument.
  • Strawberry coerces incoming argument values to the annotated Python type automatically.

Below, limit defaults to 10 and genre is an optional filter.

import strawberry
from typing import Optional


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    genre: str


LIBRARY = [
    Book(id="1", title="Dune", genre="scifi"),
    Book(id="2", title="It", genre="horror"),
]


@strawberry.type
class Query:
    @strawberry.field
    def books(self, limit: int = 10, genre: Optional[str] = None) -> list[Book]:
        items = LIBRARY if genre is None else [b for b in LIBRARY if b.genre == genre]
        return items[:limit]


schema = strawberry.Schema(query=Query)
print(schema.execute_sync('{ books(genre: "scifi") { title } }').data)

Input Types for Mutations

Mutations that accept structured data should use an input type: a class decorated with @strawberry.input. Input types are the GraphQL equivalent of a request body — they keep mutation signatures clean and self-documenting.

  • Fields without defaults are required input fields.
  • Reuse the same input across create/update flows by making fields optional where appropriate.
import strawberry
from typing import Optional


@strawberry.input
class AddBookInput:
    title: str
    author: str
    pages: Optional[int] = None

The Mutation Root Type

The Mutation root mirrors Query but expresses writes. Each method is a @strawberry.mutation. Convention: take an input type, perform the side effect, and return the created or updated object so the client can read fresh fields in one round trip.

This example keeps an in-memory store and returns the new Book. It is fully standalone and runnable.

import strawberry

_DB: list["Book"] = []


@strawberry.type
class Book:
    id: strawberry.ID
    title: str
    author: str


@strawberry.input
class AddBookInput:
    title: str
    author: str


@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> list[Book]:
        return _DB


@strawberry.type
class Mutation:
    @strawberry.mutation
    def add_book(self, data: AddBookInput) -> Book:
        book = Book(id=str(len(_DB) + 1), title=data.title, author=data.author)
        _DB.append(book)
        return book


schema = strawberry.Schema(query=Query, mutation=Mutation)
q = 'mutation { addBook(data: {title: "Dune", author: "Herbert"}) { id title } }'
print(schema.execute_sync(q).data)

Async Resolvers

Because Strawberry runs on ASGI, resolvers can be async. This matters on FastAPI: your resolvers will await database calls, HTTP clients, or cache lookups without blocking the event loop.

  • Just declare async def — Strawberry awaits it for you.
  • Mix sync and async resolvers freely in the same schema.
  • Use async resolvers for any I/O so a single GraphQL request with many fields stays non-blocking.
import strawberry
import asyncio


@strawberry.type
class Stats:
    total_books: int


async def fetch_count() -> int:
    await asyncio.sleep(0)  # stand-in for an async DB call
    return 42


@strawberry.type
class Query:
    @strawberry.field
    async def stats(self) -> Stats:
        return Stats(total_books=await fetch_count())


schema = strawberry.Schema(query=Query)
print(asyncio.run(schema.execute("{ stats { totalBooks } }")).data)

Mounting on FastAPI with GraphQLRouter

Strawberry ships strawberry.fastapi.GraphQLRouter, an APIRouter you mount with app.include_router. It serves the GraphQL endpoint and an in-browser IDE (GraphiQL) at the same path.

  • Pass your built schema to the router.
  • Mount it under a path like /graphql.
  • The router uses FastAPI's event loop, so async resolvers and FastAPI startup/shutdown events work together.

This is framework code, so it is not runnable on a bare judge.

import strawberry
from fastapi import FastAPI
from strawberry.fastapi import GraphQLRouter


@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "world"


schema = strawberry.Schema(query=Query)
graphql_app = GraphQLRouter(schema)

app = FastAPI()
app.include_router(graphql_app, prefix="/graphql")

Sharing Dependencies via Context

The big payoff of mounting on FastAPI is shared dependencies. Pass a context_getter to GraphQLRouter — it is a FastAPI dependency callable, so it can itself Depends on a DB session, the current user, or a settings object.

Whatever the context getter returns is exposed to resolvers via strawberry.Info at info.context. This is how authentication and database sessions flow from FastAPI into your GraphQL resolvers.

from fastapi import Depends
from strawberry.fastapi import GraphQLRouter


async def get_db():
    # yield a real async session in production
    yield {"connection": "db-session"}


async def get_context(db=Depends(get_db)):
    return {"db": db, "role": "reader"}


graphql_app = GraphQLRouter(schema, context_getter=get_context)

Reading Context Inside Resolvers

To use the shared context, add an info: strawberry.Info parameter to a resolver. Strawberry injects it automatically and it never appears as a GraphQL argument. Access your dependencies through info.context.

  • info.context["db"] — the session provided by context_getter.
  • Use it to authorize: read the current user and raise on missing permissions.
  • The same context object is shared across every resolver in a single request.
import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def current_role(self, info: strawberry.Info) -> str:
        return info.context["role"]

    @strawberry.field
    def secret(self, info: strawberry.Info) -> str:
        if info.context["role"] != "admin":
            raise Exception("forbidden")
        return "top-secret"

Quick Check: Sharing the DB session

You mounted a Strawberry schema on FastAPI and need each GraphQL resolver to use the same per-request database session that your REST endpoints get from a FastAPI dependency. What is the idiomatic Strawberry + FastAPI way to wire this up?

Recap

You built a typed GraphQL schema with Strawberry and mounted it on FastAPI:

  • Types: @strawberry.type classes with type-hinted fields; strawberry.ID for identifiers and Optional for nullable fields.
  • Query: the read root, with @strawberry.field resolvers whose parameters become GraphQL arguments.
  • Mutations: @strawberry.mutation methods that take an @strawberry.input type and return the affected object.
  • Schema: strawberry.Schema(query=Query, mutation=Mutation), verifiable with execute_sync.
  • FastAPI integration: mount with GraphQLRouter, and share DB sessions and auth through context_getter + info.context, reusing FastAPI's dependency injection.

This code-first, type-safe approach keeps your GraphQL API and your FastAPI app speaking the same language — Python type hints.

Preguntas frecuentes

¿La lección «Definición de tipos, consultas y mutaciones» es gratis?

Sí — el texto completo de «Definición de tipos, consultas y mutaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de FastAPI Backend Development Bootcamp, actualiza a CoddyKit PRO. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.

¿Qué aprenderé en «Definición de tipos, consultas y mutaciones»?

Construya un esquema GraphQL tipado con Strawberry y móntelo en una aplicación FastAPI con dependencias compartidas. Practicas FastAPI Backend Development Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar FastAPI Backend Development Bootcamp?

No se requiere experiencia previa. FastAPI Backend Development Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Definición de tipos, consultas y mutaciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de FastAPI Backend Development Bootcamp?

Sí. Cada lección de FastAPI Backend Development Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Definición de tipos, consultas y mutaciones
  2. Resolución de consultas N+1 con DataLoaders
  3. Suscripciones GraphQL en tiempo real
  4. Análisis del coste de consultas y limitación de profundidad
← Volver a FastAPI Backend Development Bootcamp