If you’re into creating modern web APIs, you’ll likely want to explore FastAPI and GraphQL. These two are powerhouses when it comes to efficiency and flexibility. FastAPI is a high-performance framework for building web APIs using Python, and GraphQL is a query language that lets you ask for the data you need without over-fetching or under-fetching. This article will guide you on combining these technologies using Strawberry, a user-friendly GraphQL library for Python.

FastAPI and GraphQL are like the dynamic duo of the web API world. FastAPI stands out because it’s built on top of Starlette and Pydantic, making it excellent for creating high-performance APIs. It also uses Python’s type hints for data validation, which helps keep your code robust and maintainable. On the other side, GraphQL is a great alternative to traditional REST APIs because it lets you query exactly what you need, leading to more efficient data retrieval.

Strawberry is a modern Python library that aims to make the creation of GraphQL APIs as simple as possible. It uses Python’s type hints to construct GraphQL schemas, ensuring type safety and reducing bugs. Its API is so intuitive that even beginners can pick it up easily. Plus, it integrates smoothly with popular Python frameworks like FastAPI, Django, and Flask.

Getting started is pretty straightforward. First, make sure you have Python installed. It’s always a good idea to create a virtual environment to manage your project’s dependencies. Here’s how you can do it:

python -m venv .venv
source .venv/bin/activate

Next, you’ll need to install some essential packages. You can do this using pip:

pip install fastapi strawberry-graphql uvicorn

Now, let’s get into the fun part—integrating GraphQL with FastAPI. First, you have to define your GraphQL types using Strawberry’s decorators:

from typing import List
import strawberry

@strawberry.type
class User:
    id: int
    name: str
    age: int

Users = [User(id=1, name="Patrick", age=100)]

@strawberry.type
class Query:
    @strawberry.field
    def user(self, id: int) -> User:
        for user in Users:
            if user.id == id:
                return user
        raise ValueError(f"User with id {id} not found")

Then, create the GraphQL schema using the types you defined:

schema = strawberry.Schema(query=Query)

Next, set up your FastAPI application and add the GraphQL endpoint:

from fastapi import FastAPI
from strawberry.asgi import GraphQL

app = FastAPI()

graphql_app = GraphQL(schema)

app.add_route("/graphql", graphql_app)
app.add_websocket_route("/graphql", graphql_app)

Finally, run your application using Uvicorn:

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Here’s the complete example code to get everything up and running:

from typing import List
import strawberry
from fastapi import FastAPI
from strawberry.asgi import GraphQL
import uvicorn

@strawberry.type
class User:
    id: int
    name: str
    age: int

Users = [User(id=1, name="Patrick", age=100)]

@strawberry.type
class Query:
    @strawberry.field
    def user(self, id: int) -> User:
        for user in Users:
            if user.id == id:
                return user
        raise ValueError(f"User with id {id} not found")

schema = strawberry.Schema(query=Query)

app = FastAPI()

graphql_app = GraphQL(schema)

app.add_route("/graphql", graphql_app)
app.add_websocket_route("/graphql", graphql_app)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Using Strawberry with FastAPI offers several benefits. For one, it leverages Python’s type hints to make sure your GraphQL schema is type-safe, reducing the chances of bugs and making your code more maintainable. Plus, Strawberry’s API is easy to learn and highly intuitive, making it accessible for developers at any skill level.

Strawberry also makes full use of modern Python features like data classes and async/await syntax, resulting in cleaner, more readable code. The best part is its seamless integration with FastAPI, so you can easily combine normal FastAPI path operations with GraphQL on the same app.

Imagine a real-world scenario where you’re building an API to manage second-hand automobile data. This can be a perfect case to employ FastAPI and GraphQL.

Start by defining your models using Strawberry types:

@strawberry.type
class Vehicle:
    id: int
    make: str
    model: str
    year: int

Vehicles = [Vehicle(id=1, make="Toyota", model="Corolla", year=2015)]

Then, define your queries and mutations to handle data retrieval and updates:

@strawberry.type
class Query:
    @strawberry.field
    def vehicle(self, id: int) -> Vehicle:
        for vehicle in Vehicles:
            if vehicle.id == id:
                return vehicle
        raise ValueError(f"Vehicle with id {id} not found")

@strawberry.type
class Mutation:
    @strawberry.mutation
    def create_vehicle(self, make: str, model: str, year: int) -> Vehicle:
        new_vehicle = Vehicle(id=len(Vehicles) + 1, make=make, model=model, year=year)
        Vehicles.append(new_vehicle)
        return new_vehicle

Next, set up your GraphQL schema including your queries and mutations:

schema = strawberry.Schema(query=Query, mutation=Mutation)

Lastly, integrate the GraphQL schema with your FastAPI application:

app = FastAPI()

graphql_app = GraphQL(schema)

app.add_route("/graphql", graphql_app)
app.add_websocket_route("/graphql", graphql_app)

Building APIs with the combination of GraphQL and FastAPI offers a powerful and flexible approach to managing data. This combination allows you to create efficient, type-safe, and maintainable APIs. Whether your project is small or large-scale, the duo provides the tools necessary for delivering robust and scalable solutions.

The journey to mastering these technologies comes through consistent practice and continuous learning. Armed with the knowledge from this article, you’re ready to start building your own FastAPI and GraphQL applications. Happy coding!