strawberry-graphql

You can now configure your schemas to provide a custom subclass of strawberry.types.Info to your types and queries.

import strawberry
from strawberry.schema.config import StrawberryConfig

from .models import ProductModel


class CustomInfo(strawberry.Info):
    @property
    def selected_group_id(self) -> int | None:
        """Get the ID of the group you're logged in as."""
        return self.context["request"].headers.get("Group-ID")


@strawberry.type
class Group:
    id: strawberry.ID
    name: str


@strawberry.type
class User:
    id: strawberry.ID
    name: str
    group: Group


@strawberry.type
class Query:
    @strawberry.field
    def user(self, id: strawberry.ID, info: CustomInfo) -> Product:
        kwargs = {"id": id, "name": ...}

        if info.selected_group_id is not None:
            # Get information about the group you're a part of, if
            # available.
            kwargs["group"] = ...

        return User(**kwargs)


schema = strawberry.Schema(
    Query,
    config=StrawberryConfig(info_class=CustomInfo),
)

Releases contributed by @parafoxia via #3592

This release fixes how we check for multipart subscriptions to be in line with the latest changes in the spec.

Releases contributed by @patrick91 via #3627

This release fixes an issue that prevented extensions to receive the result from the execution context when executing operations in async.

Releases contributed by @nrbnlulu via #3629

This release updates how we check for GraphQL core's version to remove a dependency on the packaging package.

Releases contributed by @bollwyvl via #3622

This release adds support for Python 3.13 (which will be out soon!)

Releases contributed by @patrick91 via #3510

This release adds support for schema-extensions in subscriptions.

Here's a small example of how to use them (they work the same way as query and mutation extensions):

import asyncio
from typing import AsyncIterator

import strawberry
from strawberry.extensions.base_extension import SchemaExtension


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def notifications(self, info: strawberry.Info) -> AsyncIterator[str]:
        for _ in range(3):
            yield "Hello"


class MyExtension(SchemaExtension):
    async def on_operation(self):
        # This would run when the subscription starts
        print("Subscription started")
        yield
        # The subscription has ended
        print("Subscription ended")


schema = strawberry.Schema(
    query=Query, subscription=Subscription, extensions=[MyExtension]
)

Releases contributed by @nrbnlulu via #3554

This release fixes a TypeError on Python 3.8 due to us using a asyncio.Queue[Tuple[bool, Any]](1) instead of asyncio.Queue(1).

Releases contributed by @szokeasaurusrex via #3615

This release fixes an issue with the http multipart subscription where the status code would be returned as None, instead of 200.

We also took the opportunity to update the internals to better support additional protocols in future.

Releases contributed by @patrick91 via #3610

This release adds support for multipart subscriptions in almost all[^1] of our http integrations!

Multipart subcriptions are a new protocol from Apollo GraphQL, built on the Incremental Delivery over HTTP spec, which is also used for @defer and @stream.

The main advantage of this protocol is that when using the Apollo Client libraries you don't need to install any additional dependency, but in future this feature should make it easier for us to implement @defer and @stream

Also, this means that you don't need to use Django Channels for subscription, since this protocol is based on HTTP we don't need to use websockets.

[^1]: Flask, Chalice and the sync Django integration don't support this.

Releases contributed by @patrick91 via #3076

Fix an issue where StrawberryResolver.is_async was returning False for a function decorated with asgiref's @sync_to_async.

The root cause is that in python >= 3.12 coroutine functions are market using inspect.markcoroutinefunction, which should be checked with inspect.iscoroutinefunction instead of asyncio.iscoroutinefunction

Releases contributed by @shmoon-kr via #3599

This release removes the integration of Starlite, as it has been deprecated since 11 May 2024.

If you are using Starlite, please consider migrating to Litestar (https://litestar.dev) or another alternative.

Releases contributed by @patrick91 via #3609

This release fixes the type of the ASGI request handler's scope argument, making type checkers ever so slightly happier.

Releases contributed by @DoctorJohn via #3581

This release makes the ASGI and FastAPI integrations share their HTTP request adapter code, making Strawberry ever so slightly smaller and easier to maintain.

Releases contributed by @DoctorJohn via #3582

This release adds support for GraphQL-core v3.3 (which has not yet been released). Note that we continue to support GraphQL-core v3.2 as well.

Releases contributed by @nrbnlulu via #3570

This release ensures using pydantic 2.8.0 doesn't break when using experimental pydantic_type and running mypy.

Releases contributed by @lindycoder via #3562

Update federation entity resolver exception handling to set the result to the original error instead of a GraphQLError, which obscured the original message and meta-fields.

Releases contributed by @bradleyoesch via #3144

This release fixes an issue where optional lazy types using | None were failing to be correctly resolved inside modules using future annotations, e.g.

from __future__ import annotations

from typing import Annotated, TYPE_CHECKING

import strawberry

if TYPE_CHECKING:
    from types import Group


@strawberry.type
class Person:
    group: Annotated["Group", strawberry.lazy("types.group")] | None

This should now work as expected.

Releases contributed by @bellini666 via #3576

This release changes some of the internals of Strawberry, it shouldn't be affecting most of the users, but since we have changed the structure of the code you might need to update your imports.

Thankfully we also provide a codemod for this, you can run it with:

strawberry upgrade update-imports

This release also includes additional documentation to some of the classes, methods and functions, this is in preparation for having the API reference in the documentation ✨

Releases contributed by @patrick91 via #3546

This release removes an unnecessary check from our internal GET query parsing logic making it simpler and (insignificantly) faster.

Releases contributed by @DoctorJohn via #3558

This release improves the performance when returning a lot of data, especially when using generic inputs (where we got a 7x speedup in our benchmark!).

Releases contributed by @patrick91 via #3549

This release adds a new configuration to disable field suggestions in the error response.

@strawberry.type
class Query:
    name: str


schema = strawberry.Schema(
    query=Query, config=StrawberryConfig(disable_field_suggestions=True)
)

Trying to query { nam } will not suggest to query name instead.

Releases contributed by @patrick91 via #3537

Fixes a bug where pydantic models as the default value for an input did not print the proper schema. See this issue.

Releases contributed by @ppease via #3499

This release fixes an issue when trying to retrieve specialized type vars from a generic type that has been aliased to a name, in cases like:

@strawberry.type
class Fruit(Generic[T]): ...


SpecializedFruit = Fruit[str]

Releases contributed by @bellini666 via #3535

Improved error message when supplying GlobalID with invalid or unknown type name component

Releases contributed by @diesieben07 via #3533

This release separates the relay.ListConnection logic that calculates the slice of the nodes into a separate function.

This allows for easier reuse of that logic for other places/libraries.

The new function lives in the strawberry.relay.utils and can be used by calling SliceMetadata.from_arguments.

This has no implications to end users.

Releases contributed by @bellini666 via #3530

This release fixes a typing issue where trying to type a root argument with strawberry.Parent would fail, like in the following example:

import strawberry


@strawberry.type
class SomeType:
    @strawberry.field
    def hello(self, root: strawberry.Parent[str]) -> str:
        return "world"

This should now work as intended.

Releases contributed by @bellini666 via #3529

This release fixes an introspection issue when requesting isOneOf on built-in scalars, like String.

Releases contributed by @patrick91 via #3528

This release exposes get_arguments in the schema_converter module to allow integrations, such as strawberry-django, to reuse that functionality if needed.

This is an internal change with no impact for end users.

Releases contributed by @bellini666 via #3527

This release refactors our Federation integration to create types using Strawberry directly, instead of using low level types from GraphQL-core.

The only user facing change is that now the info object passed to the resolve_reference function is the strawberry.Info object instead of the one coming coming from GraphQL-core. This is a breaking change for users that were using the info object directly.

If you need to access the original info object you can do so by accessing the _raw_info attribute.

import strawberry


@strawberry.federation.type(keys=["upc"])
class Product:
    upc: str

    @classmethod
    def resolve_reference(cls, info: strawberry.Info, upc: str) -> "Product":
        # Access the original info object
        original_info = info._raw_info

        return Product(upc=upc)

Releases contributed by @patrick91 via #3525

This release fixes an issue that would prevent using lazy aliased connections to annotate a connection field.

For example, this should now work correctly:

# types.py


@strawberry.type
class Fruit: ...


FruitConnection: TypeAlias = ListConnection[Fruit]

# schema.py


@strawberry.type
class Query:
    fruits: Annotated["FruitConnection", strawberry.lazy("types")] = (
        strawberry.connection()
    )

Releases contributed by @bellini666 via #3524

This release fixes an issue where mypy would complain when using a typed async resolver with strawberry.field(resolver=...).

Now the code will type check correctly. We also updated our test suite to make we catch similar issues in the future.

Releases contributed by @patrick91 via #3516

This release improves type checking for async resolver functions when used as strawberry.field(resolver=resolver_func).

Now doing this will raise a type error:

import strawberry


def some_resolver() -> int:
    return 0


@strawberry.type
class User:
    # Note the field being typed as str instead of int
    name: str = strawberry.field(resolver=some_resolver)

Releases contributed by @bricker via #3241

Fixes an issue where lazy annotations raised an error when used together with a List

Releases contributed by @jeich via #3388

When calling the CLI without all the necessary dependencies installed, a MissingOptionalDependenciesError will be raised instead of a ModuleNotFoundError. This new exception will provide a more helpful hint regarding how to fix the problem.

Releases contributed by @parafoxia via #3511

This release adds support for @oneOf on input types! 🎉 You can use one_of=True on input types to create an input type that should only have one of the fields set.

import strawberry


@strawberry.input(one_of=True)
class ExampleInputTagged:
    a: str | None = strawberry.UNSET
    b: int | None = strawberry.UNSET

Releases contributed by @patrick91 via #3429

This release fixes an issue when using Annotated + strawberry.lazy + deferred annotations such as:

from __future__ import annotations
import strawberry
from typing import Annotated


@strawberry.type
class Query:
    a: Annotated["datetime", strawberry.lazy("datetime")]


schema = strawberry.Schema(Query)

Before this would only work if datetime was not inside quotes. Now it should work as expected!

Releases contributed by @bellini666 via #3507

This release fixes a regression from 0.229.0 where using a generic interface inside a union would return an error.

Releases contributed by @patrick91 via #3502

This release improves our support for generic types, now using the same the same generic multiple times with a list inside an interface or union is supported, for example the following will work:

import strawberry


@strawberry.type
class BlockRow[T]:
    items: list[T]


@strawberry.type
class Query:
    @strawberry.field
    def blocks(self) -> list[BlockRow[str] | BlockRow[int]]:
        return [
            BlockRow(items=["a", "b", "c"]),
            BlockRow(items=[1, 2, 3, 4]),
        ]


schema = strawberry.Schema(query=Query)

Releases contributed by @patrick91 via #3463

This releases updates the JSON scalar definition to have the updated specifiedBy URL.

The release is marked as minor because it will change the generated schema if you're using the JSON scalar.

Releases contributed by @Birdi7 via #3478

This releases updates the field-extensions documentation's StrawberryField stability warning to include stable features.

The release is marked as patch because it only changes documentation.

Releases contributed by @fireteam99 via #3496

Fix AssertionError caused by the DatadogTracingExtension whenever the query is unavailable.

The bug in question was reported by issue #3150. The datadog extension would throw an AssertionError whenever there was no query available. This could happen if, for example, a user POSTed something to /graphql with a JSON that doesn't contain a query field as per the GraphQL spec.

The fix consists of adding query_missing to the operation_type tag, and also adding query_missing to the resource name. It also makes it easier to look for logs of users making invalid queries by searching for query_missing in Datadog.

Releases contributed by @serramatutu via #3483

Deprecations: This release deprecates the Starlite integration in favour of the LiteStar integration. Refer to the LiteStar integration for more information. LiteStar is a renamed and upgraded version of Starlite.

Before:

from strawberry.starlite import make_graphql_controller

After:

from strawberry.litestar import make_graphql_controller

Releases contributed by @Birdi7 via #3492

This release fixes a bug in release 0.227.3 where FragmentSpread nodes were not resolving edges.

Releases contributed by @euriostigue via #3487

This release adds an optimization to ListConnection such that only queries with edges or pageInfo in their selected fields triggers resolve_edges.

This change is particularly useful for the strawberry-django extension's ListConnectionWithTotalCount and the only selected field is totalCount. An extraneous SQL query is prevented with this optimization.

Releases contributed by @euriostigue via #3480

This release fixes a minor issue where the docstring for the relay util to_base64 described the return type incorrectly.

Releases contributed by @gbannerman via #3467

This release fixes an issue where annotations on @strawberry.types were overridden by our code. With release all annotations should be preserved.

This is useful for libraries that use annotations to introspect Strawberry types.

Releases contributed by @patrick91 via #3003

This release improves the schema codegen, making it more robust and easier to use.

It does this by introducing a directed acyclic graph for the schema codegen, which should reduce the amount of edits needed to make the generated code work, since it will be able to generate the code in the correct order (based on the dependencies of each type).

Releases contributed by @patrick91 via #3116

This release updates our Mypy plugin to add support for Pydantic >= 2.7.0

Releases contributed by @patrick91 via #3462

This releases fixes a bug in the mypy plugin where the from_pydantic method was not correctly typed.

Releases contributed by @Corentin-Br via #3368

Starting with this release, any error raised from within schema extensions will abort the operation and is returned to the client.

This corresponds to the way we already handle field extension errors and resolver errors.

This is particular useful for schema extensions performing checks early in the request lifecycle, for example:

class MaxQueryLengthExtension(SchemaExtension):
    MAX_QUERY_LENGTH = 8192

    async def on_operation(self):
        if len(self.execution_context.query) > self.MAX_QUERY_LENGTH:
            raise StrawberryGraphQLError(message="Query too large")
        yield