NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →

PyPI · #1727 most downloaded on PyPI

strawberry-graphql

0.327.77.1M downloads/mostrawberry-graphql/strawberry ↗New releases in your daily digest, changelog included.

A library for creating GraphQL APIs

Last release 10 days ago
07 Sep 2026
Ships fairly regularly
a new release about every 2 weeks
Nearly every release is documented
notes for 60 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
8 years old
1114 releases · first in 2019

Release timeline

1114 releases since 2019

20192020202120222023202420252026

Releases

0.266.16 May 20253 sources agree

This release adds a new (preferable) way to handle optional updates. Up until now when you wanted to inffer if an input value was null or absent you'd

This release adds a new (preferable) way to handle optional updates. Up until now when you wanted to inffer if an input value was null or absent you'd use strawberry.UNSET which is a bit cumbersome and error prone.

Now you can use strawberry.Maybe to identify if a value was provided or not.

e.g.

import strawberry


@strawberry.type
class User:
    name: str
    phone: str | None


@strawberry.input
class UpdateUserInput:
    name: str
    phone: strawberry.Maybe[str]


@strawberry.type
class Mutation:
    def update_user(self, input: UpdateUserInput) -> None:
        reveal_type(input.phone)  # strawberry.Some[str | None] | None

        if input.phone:
            reveal_type(input.phone.value)  # str | None

            update_user_phone(input.phone.value)

Or, if you can use pattern matching:

@strawberry.type
class Mutation:
    def update_user(self, input: UpdateUserInput) -> None:
        match input.phone:
            case strawberry.Some(value=value):
                update_user_phone(input.phone.value)

You can also use strawberry.Maybe as a field argument like so

import strawberry


@strawberry.field
def filter_users(self, phone: strawberry.Maybe[str] = None) -> list[User]:
    if phone:
        return filter_users_by_phone(phone.value)

    return get_all_users()

Releases contributed by @nrbnlulu via #3791

Open source →

This release adds support for custom names in enum values using the name parameter in strawberry.enum_value.

This allows you to specify a different name for an enum value in the GraphQL schema while keeping the original Python enum member name. For example:

@strawberry.enum
class IceCreamFlavour(Enum):
    VANILLA = "vanilla"
    CHOCOLATE_COOKIE = strawberry.enum_value("chocolate", name="chocolateCookie")

This will produce a GraphQL schema with the custom name:

enum IceCreamFlavour {
    VANILLA
    chocolateCookie
}

Releases contributed by @patrick91 via #3841

Open source →

0.265.015 Apr 2025

This release adds support for using strawberry.union with generics, like in this example:

This release adds support for using strawberry.union with generics, like in this example:

@strawberry.type
class ObjectQueries[T]:
    @strawberry.field
    def by_id(
        self, id: strawberry.ID
    ) -> Union[T, Annotated[NotFoundError, strawberry.union("ByIdResult")]]: ...


@strawberry.type
class Query:
    @strawberry.field
    def some_type_queries(self, id: strawberry.ID) -> ObjectQueries[SomeType]: ...

which, now, creates a correct union type named SomeTypeByIdResult

Releases contributed by @enoua5 via #3515

Open source →

Additional notes2 sources agree

This release adds support for using strawberry.union with generics, like in this example:

@strawberry.type
class ObjectQueries[T]:
    @strawberry.field
    def by_id(
        self, id: strawberry.ID
    ) -> Union[T, Annotated[NotFoundError, strawberry.union("ByIdResult")]]: ...


@strawberry.type
class Query:
    @strawberry.field
    def some_type_queries(self, id: strawberry.ID) -> ObjectQueries[SomeType]: ...

which, now, creates a correct union type named SomeTypeByIdResult

Contributed by Jacob Allen via PR #3515

Open source →

0.264.012 Apr 20253 sources agree

This releases improves support for relay.Edge subclasses.

This releases improves support for relay.Edge subclasses.

resolve_edge now accepts **kwargs, so custom fields can be added to your edge classes without wholly replacing resolve_edge:

@strawberry.type(name="Edge", description="An edge in a connection.")
class CustomEdge(relay.Edge[NodeType]):
    index: int

    @classmethod
    def resolve_edge(cls, node: NodeType, *, cursor: Any = None, **kwargs: Any) -> Self:
        assert isinstance(cursor, int)
        return super().resolve_edge(node, cursor=cursor, index=cursor, **kwargs)

You can also specify a custom cursor prefix, in case you want to implement a different kind of cursor than a plain ListConnection:

@strawberry.type(name="Edge", description="An edge in a connection.")
class CustomEdge(relay.Edge[NodeType]):
    CURSOR_PREFIX: ClassVar[str] = "mycursor"

Releases contributed by @diesieben07 via #3836

Open source →

0.263.01 Apr 2025

Adds the ability to include pydantic computed fields when using pydantic.type decorator.

Adds the ability to include pydantic computed fields when using pydantic.type decorator.

Example:

class UserModel(pydantic.BaseModel):
    age: int

    @computed_field
    @property
    def next_age(self) -> int:
        return self.age + 1


@strawberry.experimental.pydantic.type(
    UserModel, all_fields=True, include_computed=True
)
class User:
    pass

Will allow nextAge to be requested from a user entity.

Releases contributed by @tylernisonoff via #3798

Open source →

Additional notes2 sources agree

Adds the ability to include pydantic computed fields when using pydantic.type decorator.

Example:

class UserModel(pydantic.BaseModel):
    age: int

    @computed_field
    @property
    def next_age(self) -> int:
        return self.age + 1


@strawberry.experimental.pydantic.type(
    UserModel, all_fields=True, include_computed=True
)
class User:
    pass

Will allow nextAge to be requested from a user entity.

Contributed by Tyler Nisonoff via PR #3798

Open source →

0.262.04 Mar 2025

This release adds support for exporting schema created by a callable:

This release adds support for exporting schema created by a callable:

strawberry export-schema package.module:create_schema

when

def create_schema():
    return strawberry.Schema(query=Query)

Releases contributed by @alexey-pelykh via #3797

Open source →

Additional notes

This release adds support for exporting schema created by a callable:

strawberry export-schema package.module:create_schema

when

def create_schema():
    return strawberry.Schema(query=Query)

Contributed by Alexey Pelykh via PR #3797

Open source →

Additional notes

This release adds support for exporting schema created by a callable:

Terminal window

strawberry export-schema package.module:create_schema

when

def create_schema ():

return strawberry.Schema( query =Query)

Contributed by Alexey Pelykh via PR #3797

Open source →

0.261.027 Feb 2025

This release adds support for type[strawberry.UNSET] in addition to strawberry.types.unset.UnsetType for annotations.

This release adds support for type[strawberry.UNSET] in addition to strawberry.types.unset.UnsetType for annotations.

@strawberry.type
class User:
    name: str | None = UNSET
    age: int | None | type[strawberry.UNSET] = UNSET

Releases contributed by @alexey-pelykh via #3765

Open source →

Additional notes2 sources agree

This release adds support for type[strawberry.UNSET] in addition to strawberry.types.unset.UnsetType for annotations.

@strawberry.type
class User:
    name: str | None = UNSET
    age: int | None | type[strawberry.UNSET] = UNSET

Contributed by Alexey Pelykh via PR #3765

Open source →

0.260.213 Feb 20253 sources agree

This release fixes an issue where directives with input types using snake_case would not be printed in the schema.

This release fixes an issue where directives with input types using snake_case would not be printed in the schema.

For example, the following:

@strawberry.input
class FooInput:
    hello: str
    hello_world: str


@strawberry.schema_directive(locations=[Location.FIELD_DEFINITION])
class FooDirective:
    input: FooInput


@strawberry.type
class Query:
    @strawberry.field(
        directives=[
            FooDirective(input=FooInput(hello="hello", hello_world="hello world")),
        ]
    )
    def foo(self, info) -> str: ...

Would previously print as:

directive @fooDirective(
  input: FooInput!
  optionalInput: FooInput
) on FIELD_DEFINITION

type Query {
  foo: String! @fooDirective(input: { hello: "hello" })
}

input FooInput {
  hello: String!
  hello_world: String!
}

Now it will be correctly printed as:

directive @fooDirective(
  input: FooInput!
  optionalInput: FooInput
) on FIELD_DEFINITION

type Query {
  foo: String!
    @fooDirective(input: { hello: "hello", helloWorld: "hello world" })
}

input FooInput {
  hello: String!
  hello_world: String!
}

Releases contributed by @bellini666 via #3780

Open source →

0.258.19 Feb 20253 sources agree

This release adjusts the schema printer to avoid printing a schema directive value set to UNSET as "" (empty string).

This release adjusts the schema printer to avoid printing a schema directive value set to UNSET as "" (empty string).

For example, the following:

@strawberry.input
class FooInput:
    a: str | None = strawberry.UNSET
    b: str | None = strawberry.UNSET


@strawberry.schema_directive(locations=[Location.FIELD_DEFINITION])
class FooDirective:
    input: FooInput


@strawberry.type
class Query:
    @strawberry.field(directives=[FooDirective(input=FooInput(a="aaa"))])
    def foo(self, info) -> str: ...

Would previously print as:

directive @fooDirective(
  input: FooInput!
  optionalInput: FooInput
) on FIELD_DEFINITION

type Query {
  foo: String! @fooDirective(input: { a: "aaa", b: "" })
}

input FooInput {
  a: String
  b: String
}

Now it will be correctly printed as:

directive @fooDirective(
  input: FooInput!
  optionalInput: FooInput
) on FIELD_DEFINITION

type Query {
  foo: String! @fooDirective(input: { a: "aaa" })
}

input FooInput {
  a: String
  b: String
}

Releases contributed by @bellini666 via #3770

Open source →

0.258.012 Jan 20253 sources agree

Add the ability to override the "max results" a relay's connection can return on a per-field basis.

Add the ability to override the "max results" a relay's connection can return on a per-field basis.

The default value for this is defined in the schema's config, and set to 100 unless modified by the user. Now, that per-field value will take precedence over it.

For example:

@strawerry.type
class Query:
    # This will still use the default value in the schema's config
    fruits: ListConnection[Fruit] = relay.connection()

    # This will reduce the maximum number of results to 10
    limited_fruits: ListConnection[Fruit] = relay.connection(max_results=10)

    # This will increase the maximum number of results to 10
    higher_limited_fruits: ListConnection[Fruit] = relay.connection(max_results=10_000)

Note that this only affects ListConnection and subclasses. If you are implementing your own connection resolver, there's an extra keyword named max_results: int | None that will be passed to it.

Releases contributed by @bellini666 via #3746

Open source →

0.255.020 Dec 20243 sources agree

This release adds support for making Relay connection optional, this is useful when you want to add permission classes to the connection and not fail

This release adds support for making Relay connection optional, this is useful when you want to add permission classes to the connection and not fail the whole query if the user doesn't have permission to access the connection.

Example:

import strawberry
from strawberry import relay
from strawberry.permission import BasePermission


class IsAuthenticated(BasePermission):
    message = "User is not authenticated"

    # This method can also be async!
    def has_permission(
        self, source: typing.Any, info: strawberry.Info, **kwargs
    ) -> bool:
        return False


@strawberry.type
class Fruit(relay.Node):
    code: relay.NodeID[int]
    name: str
    weight: float

    @classmethod
    def resolve_nodes(
        cls,
        *,
        info: strawberry.Info,
        node_ids: Iterable[str],
    ):
        return []


@strawberry.type
class Query:
    node: relay.Node = relay.node()

    @relay.connection(
        relay.ListConnection[Fruit] | None, permission_classes=[IsAuthenticated()]
    )
    def fruits(self) -> Iterable[Fruit]:
        # This can be a database query, a generator, an async generator, etc
        return all_fruits.values()

Releases contributed by @patrick91 via #3707

Open source →

0.254.013 Dec 20243 sources agree

This release adds a new on_ws_connect method to all HTTP view integrations. The method is called when a graphql-transport-ws or graphql-ws connection

This release adds a new on_ws_connect method to all HTTP view integrations. The method is called when a graphql-transport-ws or graphql-ws connection is established and can be used to customize the connection acknowledgment behavior.

This is particularly useful for authentication, authorization, and sending a custom acknowledgment payload to clients when a connection is accepted. For example:

class MyGraphQLView(GraphQLView):
    async def on_ws_connect(self, context: Dict[str, object]):
        connection_params = context["connection_params"]

        if not isinstance(connection_params, dict):
            # Reject without a custom graphql-ws error payload
            raise ConnectionRejectionError()

        if connection_params.get("password") != "secret:
            # Reject with a custom graphql-ws error payload
            raise ConnectionRejectionError({"reason": "Invalid password"})

        if username := connection_params.get("username"):
            # Accept with a custom acknowledgement payload
            return {"message": f"Hello, {username}!"}

        # Accept without a acknowledgement payload
        return await super().on_ws_connect(context)

Take a look at our documentation to learn more.

Releases contributed by @DoctorJohn via #3720

Open source →

0.248.18 Nov 2024Deprecated3 sources agree

This release fixes the following deprecation warning:

This release fixes the following deprecation warning:

Failing to pass a value to the 'type_params' parameter of 'typing._eval_type' is deprecated,
as it leads to incorrect behaviour when calling typing._eval_type on a stringified annotation
that references a PEP 695 type parameter. It will be disallowed in Python 3.15.

This was only trigger in Python 3.13 and above.

Releases contributed by @patrick91 via #3692

Open source →

0.246.19 Oct 20243 sources agree

This release adds support for using raw Python enum types in your schema (enums that are not decorated with @strawberry.enum)

This release adds support for using raw Python enum types in your schema (enums that are not decorated with @strawberry.enum)

This is useful if you have enum types from other places in your code that you want to use in strawberry. i.e

# somewhere.py
from enum import Enum


class AnimalKind(Enum):
    AXOLOTL, CAPYBARA = range(2)


# gql/animals
from somewhere import AnimalKind


@strawberry.type
class AnimalType:
    kind: AnimalKind

Releases contributed by @nrbnlulu via #3639

Open source →