CHANGELOG

0.258.0 - 2025-01-12

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.

Contributed by Thiago Bellini Ribeiro via PR #3746

0.257.0 - 2025-01-09

The common node: Node used to resolve relay nodes means we will be relying on is_type_of to check if the returned object is in fact a subclass of the Node interface.

However, integrations such as Django, SQLAlchemy and Pydantic will not return the type itself, but instead an alike object that is later resolved to the expected type.

In case there are more than one possible type defined for that model that is being returned, the first one that replies True to is_type_of check would be used in the resolution, meaning that when asking for "PublicUser:123", strawberry could end up returning "User:123", which can lead to security issues (such as data leakage).

In here we are introducing a new strawberry.cast, which will be used to mark an object with the already known type by us, and when asking for is_type_of that mark will be used to check instead, ensuring we will return the correct type.

That cast is already in place for the relay node resolution and pydantic.

Contributed by Thiago Bellini Ribeiro via PR #3749

0.256.1 - 2024-12-23

This release updates Strawberry internally to no longer pass keywords arguments to pathlib.PurePath. Support for supplying keyword arguments to pathlib.PurePath is deprecated and scheduled for removal in Python 3.14

Contributed by Jonathan Ehwald via PR #3738

0.256.0 - 2024-12-21

This release drops support for Python 3.8, which reached its end-of-life (EOL) in October 2024. The minimum supported Python version is now 3.9.

We strongly recommend upgrading to Python 3.9 or a newer version, as older versions are no longer maintained and may contain security vulnerabilities.

Contributed by Thiago Bellini Ribeiro via PR #3730

0.255.0 - 2024-12-20

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()

Contributed by Patrick Arminio via PR #3707

0.254.1 - 2024-12-20

This release updates the Context and RootValue vars to have a default value of None, this makes it easier to use the views without having to pass in a value for these vars.

Contributed by Patrick Arminio via PR #3732

0.254.0 - 2024-12-13

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.

Contributed by Jonathan Ehwald via PR #3720

0.253.1 - 2024-12-03

Description: Fixed a bug in the OpenTelemetryExtension class where the _span_holder dictionary was incorrectly shared across all instances. This was caused by defining _span_holder as a class-level attribute with a mutable default value (dict()).

Contributed by Conglei via PR #3716

0.253.0 - 2024-11-23

In this release, the return types of the get_root_value and get_context methods were updated to be consistent across all view integrations. Before this release, the return types used by the ASGI and Django views were too generic.

Contributed by Jonathan Ehwald via PR #3712

0.252.0 - 2024-11-22

The view classes of all integrations now have a decode_json method that allows you to customize the decoding of HTTP JSON requests.

This is useful if you want to use a different JSON decoder, for example, to optimize performance.

Contributed by Jonathan Ehwald via PR #3709

0.251.0 - 2024-11-21

Starting with this release, the same JSON encoder is used to encode HTTP responses and WebSocket messages.

This enables developers to override the encode_json method on their views to customize the JSON encoder used by all web protocols.

Contributed by Jonathan Ehwald via PR #3708

0.250.1 - 2024-11-19

This release refactors part of the legacy graphql-ws protocol implementation, making it easier to read, maintain, and extend.

Contributed by Jonathan Ehwald via PR #3704

0.250.0 - 2024-11-18

In this release, we migrated the graphql-transport-ws types from data classes to typed dicts. Using typed dicts enabled us to precisely model null versus undefined values, which are common in that protocol. As a result, we could remove custom conversion methods handling these cases and simplify the codebase.

Contributed by Jonathan Ehwald via PR #3701

0.249.0 - 2024-11-18

After a year-long deprecation period, the SentryTracingExtension has been removed in favor of the official Sentry SDK integration.

To migrate, remove the SentryTracingExtension from your Strawberry schema and then follow the official Sentry SDK integration guide.

Contributed by Jonathan Ehwald via PR #3672

0.248.1 - 2024-11-08

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.

Contributed by Patrick Arminio via PR #3692

0.248.0 - 2024-11-07

In this release, all types of the legacy graphql-ws protocol were refactored. The types are now much stricter and precisely model the difference between null and undefined fields. As a result, our protocol implementation and related tests are now more robust and easier to maintain.

Contributed by Jonathan Ehwald via PR #3689

0.247.2 - 2024-11-05

This release fixes the issue that some coroutines in the WebSocket protocol handlers were never awaited if clients disconnected shortly after starting an operation.

Contributed by Jonathan Ehwald via PR #3687

0.247.1 - 2024-11-01

Starting with this release, both websocket-based protocols will handle unexpected socket disconnections more gracefully.

Contributed by Jonathan Ehwald via PR #3685

0.247.0 - 2024-10-21

This release fixes a regression in the legacy GraphQL over WebSocket protocol. Legacy protocol implementations should ignore client message parsing errors. During a recent refactor, Strawberry changed this behavior to match the new protocol, where parsing errors must close the WebSocket connection. The expected behavior is restored and adequately tested in this release.

Contributed by Jonathan Ehwald via PR #3670

0.246.3 - 2024-10-21

This release addresses a bug where directives were being added multiple times when defined in an interface which multiple objects inherits from.

The fix involves deduplicating directives when applying extensions/permissions to a field, ensuring that each directive is only added once.

Contributed by Arthur via PR #3674

0.246.2 - 2024-10-12

This release tweaks the Flask integration’s render_graphql_ide method to be stricter typed internally, making type checkers ever so slightly happier.

Contributed by Jonathan Ehwald via PR #3666

0.246.1 - 2024-10-09

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

from enum import Enum


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


# gql/animals
from somewhere import AnimalKind


@strawberry.type
class AnimalType:
    kind: AnimalKind

Contributed by ניר via PR #3639

0.246.0 - 2024-10-07

The AIOHTTP, ASGI, and Django test clients’ asserts_errors option has been renamed to assert_no_errors to better reflect its purpose. This change is backwards-compatible, but the old option name will raise a deprecation warning.

Contributed by Jonathan Ehwald via PR #3661

0.245.0 - 2024-10-07

This release removes the dated subscriptions_enabled setting from the Django and Channels integrations. Instead, WebSocket support is now enabled by default in all GraphQL IDEs.

Contributed by Jonathan Ehwald via PR #3660

0.244.1 - 2024-10-06

Fixes an issue where the codegen tool would crash when working with a nullable list of types.

Contributed by Jacob Allen via PR #3653

0.244.0 - 2024-10-05

Starting with this release, WebSocket logic now lives in the base class shared between all HTTP integrations. This makes the behaviour of WebSockets much more consistent between integrations and easier to maintain.

Contributed by Jonathan Ehwald via PR #3638

0.243.1 - 2024-09-26

This releases adds support for Pydantic 2.9.0’s Mypy plugin

Contributed by Krisque via PR #3632

0.243.0 - 2024-09-25

Starting with this release, multipart uploads are disabled by default and Strawberry Django view is no longer implicitly exempted from Django’s CSRF protection. Both changes relieve users from implicit security implications inherited from the GraphQL multipart request specification which was enabled in Strawberry by default.

These are breaking changes if you are using multipart uploads OR the Strawberry Django view. Migrations guides including further information are available on the Strawberry website.

Contributed by Jonathan Ehwald via PR #3645

0.242.0 - 2024-09-19

Starting with this release, clients using the legacy graphql-ws subprotocol will receive an error when they try to send binary data frames. Before, binary data frames were silently ignored.

While vaguely defined in the protocol, the legacy graphql-ws subprotocol is generally understood to only support text data frames.

Contributed by Jonathan Ehwald via PR #3633

0.241.0 - 2024-09-16

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),
)

Contributed by Ethan Henderson via PR #3592

0.240.4 - 2024-09-13

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

Contributed by Patrick Arminio via PR #3627

0.240.3 - 2024-09-12

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

Contributed by ניר via PR #3629

0.240.2 - 2024-09-11

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

Contributed by Nicholas Bollweg via PR #3622

0.240.1 - 2024-09-11

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

Contributed by Patrick Arminio via PR #3510

0.240.0 - 2024-09-10

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]
)

Contributed by ניר via PR #3554

0.239.2 - 2024-09-03

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).

Contributed by Daniel Szoke via PR #3615

0.239.1 - 2024-09-02

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.

Contributed by Patrick Arminio via PR #3610

0.239.0 - 2024-08-31

This release adds support for multipart subscriptions in almost all¹ 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.

Contributed by Patrick Arminio via PR #3076

0.238.1 - 2024-08-30

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

Contributed by Hyun S. Moon via PR #3599

0.238.0 - 2024-08-30

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.

Contributed by Patrick Arminio via PR #3609

0.237.3 - 2024-07-31

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

Contributed by Jonathan Ehwald via PR #3581

0.237.2 - 2024-07-26

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

Contributed by Jonathan Ehwald via PR #3582

0.237.1 - 2024-07-24

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.

Contributed by ניר via PR #3570

0.237.0 - 2024-07-24

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

Contributed by Martin Roy via PR #3562

0.236.2 - 2024-07-23

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.

Contributed by Bradley Oesch via PR #3144

0.236.1 - 2024-07-23

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.

Contributed by Thiago Bellini Ribeiro via PR #3576

0.236.0 - 2024-07-17

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 ✨

Contributed by Patrick Arminio via PR #3546

0.235.2 - 2024-07-08

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

Contributed by Jonathan Ehwald via PR #3558

0.235.1 - 2024-06-26

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!).

Contributed by Patrick Arminio via PR #3549

0.235.0 - 2024-06-10

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.

Contributed by Patrick Arminio via PR #3537

0.234.3 - 2024-06-10

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

Contributed by ppease via PR #3499

0.234.2 - 2024-06-07

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]

Contributed by Thiago Bellini Ribeiro via PR #3535

0.234.1 - 2024-06-06

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

Contributed by Take Weiland via PR #3533

0.234.0 - 2024-06-01

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.

Contributed by Thiago Bellini Ribeiro via PR #3530

0.233.3 - 2024-05-31

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.

Contributed by Thiago Bellini Ribeiro via PR #3529

0.233.2 - 2024-05-31

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

Contributed by Patrick Arminio via PR #3528

0.233.1 - 2024-05-30

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.

Contributed by Thiago Bellini Ribeiro via PR #3527

0.233.0 - 2024-05-29

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)

Contributed by Patrick Arminio via PR #3525

0.232.2 - 2024-05-28

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

For example, this should now work correctly:

@strawberry.type
class Fruit: ...


FruitConnection: TypeAlias = ListConnection[Fruit]

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

Contributed by Thiago Bellini Ribeiro via PR #3524

0.232.1 - 2024-05-27

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.

Contributed by Patrick Arminio via PR #3516

0.232.0 - 2024-05-25

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)

Contributed by Bryan Ricker via PR #3241

0.231.1 - 2024-05-25

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

Contributed by jeich via PR #3388

0.231.0 - 2024-05-25

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.

Contributed by Ethan Henderson via PR #3511

0.230.0 - 2024-05-22

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

Contributed by Patrick Arminio via PR #3429

0.229.2 - 2024-05-22

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!

Contributed by Thiago Bellini Ribeiro via PR #3507

0.229.1 - 2024-05-15

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

Contributed by Patrick Arminio via PR #3502

0.229.0 - 2024-05-12

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)

Contributed by Patrick Arminio via PR #3463

0.228.0 - 2024-05-12

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.

Contributed by Egor via PR #3478

0.227.7 - 2024-05-12

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.

Contributed by Ray Sy via PR #3496

0.227.6 - 2024-05-11

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.

Contributed by Lucas Valente via PR #3483

0.227.5 - 2024-05-11

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

Contributed by Egor via PR #3492

0.227.4 - 2024-05-09

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

Contributed by Eric Uriostigue via PR #3487

0.227.3 - 2024-05-01

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.

Contributed by Eric Uriostigue via PR #3480

0.227.2 - 2024-04-21

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

Contributed by Gavin Bannerman via PR #3467

0.227.1 - 2024-04-20

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.

Contributed by Patrick Arminio via PR #3003

0.227.0 - 2024-04-19

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).

Contributed by Patrick Arminio via PR #3116

0.226.2 - 2024-04-19

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

Contributed by Patrick Arminio via PR #3462

0.226.1 - 2024-04-19

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

Contributed by Corentin-Br via PR #3368

0.226.0 - 2024-04-17

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

Contributed by Jonathan Ehwald via PR #3217

0.225.1 - 2024-04-15

This change fixes GET request queries returning a 400 if a content_type header is supplied

Contributed by Nathan John via PR #3452

0.225.0 - 2024-04-14

This release adds support for using FastAPI APIRouter arguments in GraphQLRouter.

Now you have the opportunity to specify parameters such as tags, route_class, deprecated, include_in_schema, etc:

import strawberry

from fastapi import FastAPI
from strawberry.fastapi import GraphQLRouter


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


schema = strawberry.Schema(Query)

graphql_app = GraphQLRouter(schema, tags=["graphql"])

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

Contributed by Nikita Paramonov via PR #3442

0.224.2 - 2024-04-13

This releases fixes a bug where schema extensions where not running a LIFO order.

Contributed by ניר via PR #3416

0.224.1 - 2024-03-30

This release fixes a deprecation warning when using the Apollo Tracing Extension.

Contributed by A. Coady via PR #3410

0.224.0 - 2024-03-30

This release adds support for using both Pydantic v1 and v2, when importing from pydantic.v1.

This is automatically detected and the correct version is used.

Contributed by Patrick Arminio via PR #3426

0.223.0 - 2024-03-29

This release adds support for Apollo Federation in the schema codegen. Now you can convert a schema like this:

extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.3",
        import: ["@key", "@shareable"])

type Query {
  me: User
}

type User @key(fields: "id") {
  id: ID!
  username: String! @shareable
}

to a Strawberry powered schema like this:

import strawberry


@strawberry.type
class Query:
    me: User | None


@strawberry.federation.type(keys=["id"])
class User:
    id: strawberry.ID
    username: str = strawberry.federation.field(shareable=True)


schema = strawberry.federation.Schema(query=Query, enable_federation_2=True)

By running the following command:

strawberry schema-codegen example.graphql

Contributed by Patrick Arminio via PR #3417

0.222.0 - 2024-03-27

This release adds support for Apollo Federation v2.7 which includes the @authenticated, @requiresScopes, @policy directives, as well as the label argument for @override. As usual, we have first class support for them in the strawberry.federation namespace, here’s an example:

from strawberry.federation.schema_directives import Override


@strawberry.federation.type(
    authenticated=True,
    policy=[["client", "poweruser"], ["admin"]],
    requires_scopes=[["client", "poweruser"], ["admin"]],
)
class Product:
    upc: str = strawberry.federation.field(
        override=Override(override_from="mySubGraph", label="percent(1)")
    )

Contributed by Tyger Taco via PR #3420

0.221.1 - 2024-03-21

This release properly allows passing one argument to the Info class.

This is now fully supported:

import strawberry

from typing import TypedDict


class Context(TypedDict):
    user_id: str


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

Contributed by Patrick Arminio via PR #3419

0.221.0 - 2024-03-21

This release improves the Info type, by adding support for default TypeVars and by exporting it from the main module. This makes it easier to use Info in your own code, without having to import it from strawberry.types.info.

New export

By exporting Info from the main module, now you can do the follwing:

import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def info(self, info: strawberry.Info) -> str:
        # do something with info
        return "hello"

Default TypeVars

The Info type now has default TypeVars, so you can use it without having to specify the type arguments, like we did in the example above. Make sure to use the latest version of Mypy or Pyright for this. It also means that you can only pass one value to it if you only care about the context type:

import strawberry

from .context import Context


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

Contributed by Patrick Arminio via PR #3418

0.220.0 - 2024-03-08

This release adds support to allow passing connection_params as dictionary to GraphQLWebsocketCommunicator class when testing channels integration

Example

GraphQLWebsocketCommunicator(
    application=application,
    path="/graphql",
    connection_params={"username": "strawberry"},
)

Contributed by selvarajrajkanna via PR #3403

0.219.2 - 2024-02-06

This releases updates the dependency of python-multipart to be at least 0.0.7 (which includes a security fix).

It also removes the upper bound for python-multipart so you can always install the latest version (if compatible) 😊

Contributed by Srikanth via PR #3375

0.219.1 - 2024-01-28

• Improved error message when supplying in incorrect before or after argument with using relay and pagination.
• Add extra PR requirement in README.md

Contributed by SD via PR #3361

0.219.0 - 2024-01-24

This release adds support for litestar.

import strawberry
from litestar import Request, Litestar
from strawberry.litestar import make_graphql_controller
from strawberry.types.info import Info


def custom_context_getter(request: Request):
    return {"custom": "context"}


@strawberry.type
class Query:
    @strawberry.field
    def hello(self, info: strawberry.Info[object, None]) -> str:
        return info.context["custom"]


schema = strawberry.Schema(Query)


GraphQLController = make_graphql_controller(
    schema,
    path="/graphql",
    context_getter=custom_context_getter,
)

app = Litestar(
    route_handlers=[GraphQLController],
)

Contributed by Matthieu MN via PR #3213

0.218.1 - 2024-01-23

This release fixes a small issue in the GraphQL Transport websocket where the connection would fail when receiving extra parameters in the payload sent from the client.

This would happen when using Apollo Sandbox.

Contributed by Patrick Arminio via PR #3356

0.218.0 - 2024-01-22

This release adds a new method get_fields on the Schema class. You can use get_fields to hide certain field based on some conditions, for example:

@strawberry.type
class User:
    name: str
    email: str = strawberry.field(metadata={"tags": ["internal"]})


@strawberry.type
class Query:
    user: User


def public_field_filter(field: StrawberryField) -> bool:
    return "internal" not in field.metadata.get("tags", [])


class PublicSchema(strawberry.Schema):
    def get_fields(
        self, type_definition: StrawberryObjectDefinition
    ) -> List[StrawberryField]:
        return list(filter(public_field_filter, type_definition.fields))


schema = PublicSchema(query=Query)

The schema here would only have the name field on the User type.

Contributed by Patrick Arminio via PR #3274

0.217.1 - 2024-01-04

This hotfix enables permission extensions to be used with AsyncGenerators.

Contributed by Erik Wrede via PR #3318

0.217.0 - 2023-12-18

Permissions classes now use a FieldExtension. The new preferred way to add permissions is to use the PermissionsExtension class:

import strawberry
from strawberry.permission import PermissionExtension, BasePermission


class IsAuthorized(BasePermission):
    message = "User is not authorized"
    error_extensions = {"code": "UNAUTHORIZED"}

    def has_permission(self, source, info, **kwargs) -> bool:
        return False


@strawberry.type
class Query:
    @strawberry.field(extensions=[PermissionExtension(permissions=[IsAuthorized()])])
    def name(self) -> str:
        return "ABC"

The old way of adding permissions using permission_classes is still supported via the automatic addition of a PermissionExtension on the field.

⚠️ Breaking changes

Previously the kwargs argument keys for the has_permission method were using camel casing (depending on your schema configuration), now they will always follow the python name defined in your resolvers.

class IsAuthorized(BasePermission):
    message = "User is not authorized"

    def has_permission(
        self, source, info, **kwargs: typing.Any
    ) -> bool:  # pragma: no cover
        # kwargs will have a key called "a_key"
        # instead of `aKey`

        return False


@strawberry.type
class Query:
    @strawberry.field(permission_classes=[IsAuthorized])
    def name(self, a_key: str) -> str:  # pragma: no cover
        return "Erik"

Using the new PermissionExtension API, permissions support even more features:

Silent errors

To return None or [] instead of raising an error, the fail_silently keyword argument on PermissionExtension can be set to True.

Custom Error Extensions & classes

Permissions will now automatically add pre-defined error extensions to the error, and can use a custom GraphQLError class. This can be configured by modifying the error_class and error_extensions attributes on the BasePermission class.

Customizable Error Handling

To customize the error handling, the on_unauthorized method on the BasePermission class can be used. Further changes can be implemented by subclassing the PermissionExtension class.

Schema Directives

Permissions will automatically be added as schema directives to the schema. This behavior can be altered by setting the add_directives to False on PermissionExtension, or by setting the _schema_directive class attribute of the permission to a custom directive.

Contributed by Erik Wrede via PR #2570

0.216.1 - 2023-12-12

Don’t require NodeId annotation if resolve_id is overwritten on Node implemented types

Contributed by Alexander via PR #2844

0.216.0 - 2023-12-06

Override encode_json() method in Django BaseView to use DjangoJSONEncoder

Contributed by Noam Stolero via PR #3273

0.215.3 - 2023-12-06

Fixed the base view so it uses parse_json when loading parameters from the query string instead of json.loads.

Contributed by Elias Gabriel via PR #3272

0.215.2 - 2023-12-05

This release updates the Apollo Sandbox integration to all you to pass cookies to the GraphQL endpoint by enabling the Include cookes option in the Sandbox settings.

Contributed by Patrick Arminio via PR #3278

0.215.1 - 2023-11-20

Improved error message when supplying GlobalID format that relates to another type than the query itself.

Contributed by SD via PR #3194

0.215.0 - 2023-11-19

Adds an optional extensions parameter to strawberry.federation.field, with default value None. The key is passed through to strawberry.field, so the functionality is exactly as described here.

Example:

strawberry.federation.field(extensions=[InputMutationExtension()])

Contributed by Bryan Ricker via PR #3239

0.214.0 - 2023-11-15

This release updates the GraphiQL packages to their latest versions:

• graphiql@3.0.9
• @graphiql/plugin-explorer@1.0.2

Contributed by Rodrigo Feijao via PR #3227

0.213.0 - 2023-11-08

This release adds support in all all our HTTP integration for choosing between different GraphQL IDEs. For now we support GraphiQL (the default), Apollo Sandbox, and Pathfinder.

Deprecations: This release deprecates the graphiql option in all HTTP integrations, in favour of graphql_ide, this allows us to only have one settings to change GraphQL ide, or to disable it.

Here’s a couple of examples of how you can use this:

FastAPI

import strawberry

from fastapi import FastAPI
from strawberry.fastapi import GraphQLRouter
from api.schema import schema

graphql_app = GraphQLRouter(schema, graphql_ide="apollo-sandbox")

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

Django

from django.urls import path

from strawberry.django.views import GraphQLView

from api.schema import schema

urlpatterns = [
    path("graphql/", GraphQLView.as_view(schema=schema, graphql_ide="pathfinder")),
]

Contributed by Patrick Arminio via PR #3209

0.212.0 - 2023-11-07

This release changes how we check for generic types. Previously, any type that had a generic typevar would be considered generic for the GraphQL schema, this would generate un-necessary types in some cases. Now, we only consider a type generic if it has a typevar that is used as the type of a field or one of its arguments.

For example the following type:

@strawberry.type
class Edge[T]:
    cursor: strawberry.ID
    some_interna_value: strawberry.Private[T]

Will not generate a generic type in the schema, as the typevar T is not used as the type of a field or argument.

Contributed by Patrick Arminio via PR #3202

0.211.2 - 2023-11-06

This release removes unused graphiql submodules for Flask, Quart and Sanic.

Contributed by Pierre Chapuis via PR #3203

0.211.1 - 2023-10-25

This release fixes an issue that prevented the parser_cache extension to be used in combination with other extensions such as MaxTokensLimiter.

The following should work as expected now:

schema = strawberry.Schema(
    query=Query, extensions=[MaxTokensLimiter(max_token_count=20), ParserCache()]
)

Contributed by David Šanda via PR #3170

0.211.0 - 2023-10-24

This release adds a Quart view.

Contributed by Pierre Chapuis via PR #3162

0.210.0 - 2023-10-24

This release deprecates our SentryTracingExtension, as it is now incorporated directly into Sentry itself as of version 1.32.0. You can now directly instrument Strawberry with Sentry.

Below is the revised usage example:

import sentry_sdk
from sentry_sdk.integrations.strawberry import StrawberryIntegration

sentry_sdk.init(
    dsn="___PUBLIC_DSN___",
    integrations=[
        # make sure to set async_execution to False if you're executing
        # GraphQL queries synchronously
        StrawberryIntegration(async_execution=True),
    ],
    traces_sample_rate=1.0,
)

Many thanks to @sentrivana for their work on this integration!

0.209.8 - 2023-10-20

Fix strawberry mypy plugin for pydantic v2

Contributed by Corentin-Br via PR #3159

0.209.7 - 2023-10-15

Remove stack_info from error log messages to not clutter error logging with unnecessary information.

Contributed by Malte Finsterwalder via PR #3143

0.209.6 - 2023-10-07

Add text/html content-type to chalice graphiql response

Contributed by Julian Popescu via PR #3137

0.209.5 - 2023-10-03

This release adds a new private hook in our HTTP views, it is called _handle_errors and it is meant to be used by Sentry (or other integrations) to handle errors without having to patch methods that could be overridden by the users

Contributed by Patrick Arminio via PR #3127

0.209.4 - 2023-10-02

This release changes how we check for conflicting resolver arguments to exclude self from those checks, which were introduced on version 0.208.0.

It is a common pattern among integrations, such as the Django one, to use root: Model in the resolvers for better typing inference.

Contributed by Thiago Bellini Ribeiro via PR #3131

0.209.3 - 2023-10-02

Mark Django’s asyncview as a coroutine using asgiref.sync.markcoroutinefunction to support using it with Python 3.12.

Contributed by Thiago Bellini Ribeiro via PR #3124

0.209.2 - 2023-09-24

Fix generation of input based on pydantic models using nested Annotated type annotations:

import strawberry
from pydantic import BaseModel


class User(BaseModel):
    age: Optional[Annotated[int, "metadata"]]


@strawberry.experimental.pydantic.input(all_fields=True)
class UserInput:
    pass

Contributed by Matthieu MN via PR #3109

0.209.1 - 2023-09-21

This release fixes an issue when trying to generate code from a schema that was using double quotes inside descriptions.

The following schema will now generate code correctly:

"""
A type of person or character within the "Star Wars" Universe.
"""
type Species {
  """
  The classification of this species, such as "mammal" or "reptile".
  """
  classification: String!
}

Contributed by Patrick Arminio via PR #3112

0.209.0 - 2023-09-19

This release adds support for generating Strawberry types from SDL files. For example, given the following SDL file:

type Query {
  user: User
}

type User {
  id: ID!
  name: String!
}

you can run

strawberry schema-codegen schema.graphql

to generate the following Python code:

import strawberry


@strawberry.type
class Query:
    user: User | None


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


schema = strawberry.Schema(query=Query)

Contributed by Patrick Arminio via PR #3096

0.208.3 - 2023-09-19

Adding support for additional pydantic built in types like EmailStr or PostgresDsn.

Contributed by ppease via PR #3101

0.208.2 - 2023-09-18

This release fixes an issue that would prevent using generics with unnamed unions, like in this example:

from typing import Generic, TypeVar, Union
import strawberry

T = TypeVar("T")


@strawberry.type
class Connection(Generic[T]):
    nodes: list[T]


@strawberry.type
class Entity1:
    id: int


@strawberry.type
class Entity2:
    id: int


@strawberry.type
class Query:
    entities: Connection[Union[Entity1, Entity2]]

Contributed by Patrick Arminio via PR #3099

0.208.1 - 2023-09-15

This fixes a bug where codegen would choke trying to find a field in the schema for a generic type.

Contributed by Matt Gilson via PR #3077

0.208.0 - 2023-09-14

Adds new strawberry.Parent type annotation to support resolvers without use of self.

E.g.

@dataclass
class UserRow:
    id_: str


@strawberry.type
class User:
    @strawberry.field
    @staticmethod
    async def name(parent: strawberry.Parent[UserRow]) -> str:
        return f"User Number {parent.id_}"


@strawberry.type
class Query:
    @strawberry.field
    def user(self) -> User:
        return UserRow(id_="1234")

Contributed by mattalbr via PR #3017

0.207.1 - 2023-09-14

This fixes a bug where codegen would choke on FragmentSpread nodes in the GraphQL during type collection.

e.g.:

fragment PartialBlogPost on BlogPost {
  title
}

query OperationName {
  interface {
    id
    ... on BlogPost {
      ...PartialBlogPost
    }
    ... on Image {
      url
    }
  }
}

The current version of the code generator is not able to handle the ...PartialBogPost in this position because it assumes it can only find Field type nodes even though the spread should be legit.

Contributed by Matt Gilson via PR #3086

0.207.0 - 2023-09-14

This release removes the deprecated ignore argument from the QueryDepthLimiter extension.

Contributed by Kai Benevento via PR #3093

0.206.0 - 2023-09-13

strawberry codegen can now operate on multiple input query files. The previous behavior of naming the file types.js and types.py for the builtin typescript and python plugins respectively is preserved, but only if a single query file is passed. When more than one query file is passed, the code generator will now use the stem of the query file’s name to construct the name of the output files. e.g. my_query.graphql -> my_query.js or my_query.py. Creators of custom plugins are responsible for controlling the name of the output file themselves. To accomodate this, if the __init__ method of a QueryCodegenPlugin has a parameter named query or query_file, the pathlib.Path to the query file will be passed to the plugin’s __init__ method.

Finally, the ConsolePlugin has also recieved two new lifecycle methods. Unlike other QueryCodegenPlugin, the same instance of the ConsolePlugin is used for each query file processed. This allows it to keep state around how many total files were processed. The ConsolePlugin recieved two new lifecycle hooks: before_any_start and after_all_finished that get called at the appropriate times.

Contributed by Matt Gilson via PR #2911

0.205.0 - 2023-08-24

strawberry codegen previously choked for inputs that used the strawberry.UNSET sentinal singleton value as a default. The intent here is to say that if a variable is not part of the request payload, then the UNSET default value will not be modified and the service code can then treat an unset value differently from a default value, etc.

For codegen, we treat the UNSET default value as a GraphQLNullValue. The .value property is the UNSET object in this case (instead of the usual None). In the built-in python code generator, this causes the client to generate an object with a None default. Custom client generators can sniff at this value and update their behavior.

Contributed by Matt Gilson via PR #3050

0.204.0 - 2023-08-15

Adds a new flag to export-schema command, --output, which allows the user to specify the output file. If unset (current behavior), the command will continue to print to stdout.

Contributed by Chris Hua via PR #3033

0.203.3 - 2023-08-14

Mark pydantic constrained list test with need_pydantic_v1 since it is removed in pydantic V2

Contributed by tjeerddie via PR #3034

0.203.2 - 2023-08-14

Enhancements:

• Improved pydantic conversion compatibility with specialized list classes.
  • Modified StrawberryAnnotation._is_list to check if the annotation extends from the list type, enabling it to be considered a list.
  • in StrawberryAnnotation Moved the _is_list check before the _is_generic check in resolve to avoid unsupported error in _is_generic before it checked _is_list.

This enhancement enables the usage of constrained lists as class types and allows the creation of specialized lists. The following example demonstrates this feature:

import strawberry
from pydantic import BaseModel, ConstrainedList


class FriendList(ConstrainedList):
    min_items = 1


class UserModel(BaseModel):
    age: int
    friend_names: FriendList[str]


@strawberry.experimental.pydantic.type(UserModel)
class User:
    age: strawberry.auto
    friend_names: strawberry.auto

Contributed by tjeerddie via PR #2909

0.203.1 - 2023-08-12

This release updates the built-in GraphiQL to the current latest version (3.0.5), it also updates React to the current latest version (18.2.0) and uses the production distribution instead of development to reduce bundle size.

Contributed by Kien Dang via PR #3031

0.203.0 - 2023-08-10

Add support for extra colons in the GlobalID string.

Before, the string SomeType:some:value would produce raise an error saying that it was expected the string to be splited in 2 parts when doing .split(":").

Now we are using .split(":", 1), meaning that the example above will consider SomeType to be the type name, and some:value to be the node_id.

Contributed by Thiago Bellini Ribeiro via PR #3025

0.202.1 - 2023-08-09

TypingUnionType import error check is reraised because TypingGenericAlias is checked at the same time which is checked under 3.9 instead of under 3.10

Fix by separating TypingUnionType and TypingGenericAlias imports in their own try-catch

Contributed by tjeerddie via PR #3023

0.202.0 - 2023-08-08

This release updates Strawberry’s codebase to use new features in Python 3.8. It also removes backports.cached-property from our dependencies, as we can now rely on the standard library’s functools.cached_property.

Contributed by Thiago Bellini Ribeiro via PR #2995

0.201.1 - 2023-08-08

Fix strawberry mypy plugin for pydantic v1

Contributed by tjeerddie via PR #3019

0.201.0 - 2023-08-08

Fix import error in strawberry.ext.mypy_plugin for users who don’t use pydantic.

Contributed by David Němec via PR #3018

0.200.0 - 2023-08-07

Adds initial support for pydantic V2.

This is extremely experimental for wider initial testing.

We do not encourage using this in production systems yet.

Contributed by James Chua via PR #2972

0.199.3 - 2023-08-06

This release fixes an issue on relay.ListConnection where async iterables that returns non async iterable objects after being sliced where producing errors.

This should fix an issue with async strawberry-graphql-django when returning already prefetched QuerySets.

Contributed by Thiago Bellini Ribeiro via PR #3014

0.199.2 - 2023-08-03

This releases improves how we handle Annotated and async types (used in subscriptions). Previously we weren’t able to use unions with names inside subscriptions, now that’s fixed 😊

Example:

@strawberry.type
class A:
    a: str


@strawberry.type
class B:
    b: str


@strawberry.type
class Query:
    x: str = "Hello"


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def example_with_union(self) -> AsyncGenerator[Union[A, B], None]:
        yield A(a="Hi")

Contributed by Patrick Arminio via PR #3008

0.199.1 - 2023-08-02

This release fixes an issue in the graphql-ws implementation where sending a null payload would cause the connection to be closed.

Contributed by Patrick Arminio via PR #3007

0.199.0 - 2023-08-01

This release changes how we handle generic type vars, bringing support to the new generic syntax in Python 3.12 (which will be out in October).

This now works:

@strawberry.type
class Edge[T]:
    cursor: strawberry.ID
    node_field: T


@strawberry.type
class Query:
    @strawberry.field
    def example(self) -> Edge[int]:
        return Edge(cursor=strawberry.ID("1"), node_field=1)


schema = strawberry.Schema(query=Query)

Contributed by Patrick Arminio via PR #2993

0.198.0 - 2023-07-31

This release adds support for returning interfaces directly in resolvers:

@strawberry.interface
class Node:
    id: strawberry.ID

    @classmethod
    def resolve_type(cls, obj: Any, *args: Any, **kwargs: Any) -> str:
        return "Video" if obj.id == "1" else "Image"


@strawberry.type
class Video(Node): ...


@strawberry.type
class Image(Node): ...


@strawberry.type
class Query:
    @strawberry.field
    def node(self, id: strawberry.ID) -> Node:
        return Node(id=id)


schema = strawberry.Schema(query=Query, types=[Video, Image])

Contributed by Patrick Arminio via PR #2989

0.197.0 - 2023-07-30

This release removes support for Python 3.7 as its end of life was on 27 Jun 2023.

This will allow us to reduce the number of CI jobs we have, and potentially use newer features of Python. ⚡

Contributed by Alexander via PR #2907

0.196.2 - 2023-07-28

This release fixes an issue when trying to use Annotated[strawberry.auto, ...] on python 3.10 or older, which got evident after the fix from 0.196.1.

Previously we were throwing the type away, since it usually is Any, but python 3.10 and older will validate that the first argument passed for Annotated is callable (3.11+ does not do that anymore), and StrawberryAuto is not.

This changes it to keep that Any, which is also what someone would expect when resolving the annotation using our custom eval_type function.

Contributed by Thiago Bellini Ribeiro via PR #2990

0.196.1 - 2023-07-26

This release fixes an issue where annotations resolution for auto and lazy fields using Annotated where not preserving the remaining arguments because of a typo in the arguments filtering.

Contributed by Thiago Bellini Ribeiro via PR #2983

0.196.0 - 2023-07-26

This release adds support for union with a single member, they are useful for future proofing your schema in cases you know a field will be part of a union in future.

import strawberry

from typing import Annotated


@strawberry.type
class Audio:
    duration: int


@strawberry.type
class Query:
    # note: Python's Union type doesn't support single members,
    # Union[Audio] is exactly the same as Audio, so we use
    # use Annotated and strawberry.union to tell Strawberry this is
    # a union with a single member
    latest_media: Annotated[Audio, strawberry.union("MediaItem")]


schema = strawberry.Schema(query=Query)

Contributed by Patrick Arminio via PR #2982

0.195.3 - 2023-07-22

This release no longer requires an upperbound pin for uvicorn, ensuring compatibility with future versions of uvicorn without the need for updating Strawberry.

Contributed by Patrick Arminio via PR #2968

0.195.2 - 2023-07-15

This release introduces a bug fix for relay connection where previously they wouldn’t work without padding the first argument.

Contributed by Alexander via PR #2938

0.195.1 - 2023-07-15

This release fixes a bug where returning a generic type from a field that was returning an interface would throw an error.

Contributed by Patrick Arminio via PR #2955

0.195.0 - 2023-07-14

Improve the time complexity of strawberry.interface using resolve_type. Achieved time complexity is now O(1) with respect to the number of implementations of an interface. Previously, the use of is_type_of resulted in a worst-case performance of O(n).

Before:

---------------------------------------------------------------------------
Name (time in ms)                         Min                 Max
---------------------------------------------------------------------------
test_interface_performance[1]         18.0224 (1.0)       50.3003 (1.77)
test_interface_performance[16]        22.0060 (1.22)      28.4240 (1.0)
test_interface_performance[256]       69.1364 (3.84)      76.1349 (2.68)
test_interface_performance[4096]     219.6461 (12.19)    231.3732 (8.14)
---------------------------------------------------------------------------

After:

---------------------------------------------------------------------------
Name (time in ms)                        Min                Max
---------------------------------------------------------------------------
test_interface_performance[1]        14.3921 (1.0)      46.2064 (2.79)
test_interface_performance[16]       14.8669 (1.03)     16.5732 (1.0)
test_interface_performance[256]      15.8977 (1.10)     24.4618 (1.48)
test_interface_performance[4096]     18.7340 (1.30)     21.2899 (1.28)
---------------------------------------------------------------------------

Contributed by San Kilkis via PR #1949

0.194.4 - 2023-07-08

This release makes sure that Schema.process_errors() is called once for every error which happens with graphql-transport-ws operations.

Contributed by Kristján Valur Jónsson via PR #2899

0.194.3 - 2023-07-08

Added default argument to the typer Argument function, this adds support for older versions of typer.

Contributed by Jaime Coello de Portugal via PR #2906

0.194.2 - 2023-07-08

This release includes a performance improvement to strawberry.lazy() to allow relative module imports to be resolved faster.

Contributed by Karim Alibhai via PR #2926

0.194.1 - 2023-07-08

This release adds a setter on StrawberryAnnotation.annotation, this fixes an issue on Strawberry Django.

Contributed by Patrick Arminio via PR #2932

0.194.0 - 2023-07-08

Restore evaled type access in StrawberryAnnotation

Prior to Strawberry 192.2 the annotation attribute of StrawberryAnnotation would return an evaluated type when possible due reserved argument parsing. 192.2 moved the responsibility of evaluating and caching results to the evaluate method of StrawberryAnnotation. This introduced a regression when using future annotations for any code implicitely relying on the annotation attribute being an evaluated type.

To fix this regression and mimick pre-192.2 behavior, this release adds an annotation property to StrawberryAnnotation that internally calls the evaluate method. On success the evaluated type is returned. If a NameError is raised due to an unresolvable annotation, the raw annotation is returned.

Contributed by San Kilkis via PR #2925

0.193.1 - 2023-07-05

This fixes a regression from 0.190.0 where changes to the return type of a field done by Field Extensions would not be taken in consideration by the schema.

Contributed by Thiago Bellini Ribeiro via PR #2922

0.193.0 - 2023-07-04

This release updates the API to listen to Django Channels to avoid race conditions when confirming GraphQL subscriptions.

Deprecations:

This release contains a deprecation for the Channels integration. The channel_listen method will be replaced with an async context manager that returns an awaitable AsyncGenerator. This method is called listen_to_channel.

An example of migrating existing code is given below:

# Existing code
@strawberry.type
class MyDataType:
    name: str


@strawberry.type
class Subscription:
    @strawberry.subscription
    async def my_data_subscription(
        self, info: strawberry.Info, groups: list[str]
    ) -> AsyncGenerator[MyDataType | None, None]:
        yield None
        async for message in info.context["ws"].channel_listen(
            "my_data", groups=groups
        ):
            yield MyDataType(name=message["payload"])

# New code
@strawberry.type
class Subscription:
    @strawberry.subscription
    async def my_data_subscription(
        self, info: strawberry.Info, groups: list[str]
    ) -> AsyncGenerator[MyDataType | None, None]:
        async with info.context["ws"].listen_to_channel("my_data", groups=groups) as cm:
            yield None
            async for message in cm:
                yield MyDataType(name=message["payload"])

Contributed by Moritz Ulmer via PR #2856

0.192.2 - 2023-07-03

This release fixes an issue related to using typing.Annotated in resolver arguments following the declaration of a reserved argument such as strawberry.types.Info.

Before this fix, the following would be converted incorrectly:

from __future__ import annotations
import strawberry
import uuid
from typing_extensions import Annotated
from strawberry.types import Info


@strawberry.type
class Query:
    @strawberry.field
    def get_testing(
        self,
        info: strawberry.Info,
        id_: Annotated[uuid.UUID, strawberry.argument(name="id")],
    ) -> str | None:
        return None


schema = strawberry.Schema(query=Query)

print(schema)

Resulting in the schema:

type Query {
  getTesting(id_: UUID!): String # ⬅️ see `id_`
}

scalar UUID

After this fix, the schema is converted correctly:

type Query {
  getTesting(id: UUID!): String
}

scalar UUID

Contributed by San Kilkis via PR #2901

0.192.1 - 2023-07-02

Add specifications in FastAPI doc if query via GET is enabled

Contributed by guillaumeLepape via PR #2913

0.192.0 - 2023-06-28

This release introduces a new command called upgrade, this command can be used to run codemods on your codebase to upgrade to the latest version of Strawberry.

At the moment we only support upgrading unions to use the new syntax with annotated, but in future we plan to add more commands to help with upgrading.

Here’s how you can use the command to upgrade your codebase:

strawberry upgrade annotated-union .

Contributed by Patrick Arminio via PR #2886

0.191.0 - 2023-06-28

This release adds support for declaring union types using typing.Annotated instead of strawberry.union(name, types=...).

Code using the old syntax will continue to work, but it will trigger a deprecation warning. Using Annotated will improve type checking and IDE support especially when using pyright.

Before:

Animal = strawberry.union("Animal", (Cat, Dog))

After:

from typing import Annotated, Union

Animal = Annotated[Union[Cat, Dog], strawberry.union("Animal")]

0.190.0 - 2023-06-27

This release refactors the way we resolve field types to to make it more robust, resolving some corner cases.

One case that should be fixed is when using specialized generics with future annotations.

Contributed by Alexander via PR #2868

0.189.3 - 2023-06-27

This release removes some usage of deprecated functions from GraphQL-core.

Contributed by Kristján Valur Jónsson via PR #2894

0.189.2 - 2023-06-27

The graphql-transport-ws protocol allows for subscriptions to error during execution without terminating the subscription. Non-fatal errors produced by subscriptions now produce Next messages containing an ExecutionResult with an error field and don’t necessarily terminate the subscription. This is in accordance to the behaviour of Apollo server.

Contributed by Kristján Valur Jónsson via PR #2876

0.189.1 - 2023-06-25

This release fixes a deprecation warning being triggered by the relay integration.

Contributed by Patrick Arminio via PR #2858

0.189.0 - 2023-06-22

This release updates create_type to add support for all arguments that strawberry.type supports. This includes: description, extend, directives, is_input and is_interface.

Contributed by Patrick Arminio via PR #2880

0.188.0 - 2023-06-22

This release gives codegen clients the ability to inquire about the __typename of a GraphQLObjectType. This information can be used to automatically select the proper type to hydrate when working with a union type in the response.

Contributed by Matt Gilson via PR #2875

0.187.5 - 2023-06-21

This release fixes a regression when comparing a StrawberryAnnotation instance with anything that is not also a StrawberryAnnotation instance, which caused it to raise a NotImplementedError.

This reverts its behavior back to how it worked before, where it returns NotImplemented instead, meaning that the comparison can be delegated to the type being compared against or return False in case it doesn’t define an __eq__ method.

Contributed by Thiago Bellini Ribeiro via PR #2879

0.187.4 - 2023-06-21

graphql-transport-ws handler now uses a single dict to manage active operations.

Contributed by Kristján Valur Jónsson via PR #2699

0.187.3 - 2023-06-21

This release fixes a typing regression on StraberryContainer subclasses where type checkers would not allow non WithStrawberryObjectDefinition types to be passed for its of_type argument (e.g. StrawberryOptional(str))

Contributed by Thiago Bellini Ribeiro via PR #2878

0.187.2 - 2023-06-21

This release removes get_object_definition_strict and instead overloads get_object_definition to accept an extra strct keyword.

This is a new feature so it is unlikely to break anything.

Contributed by Thiago Bellini Ribeiro via PR #2877

0.187.1 - 2023-06-21

This release bumps the minimum requirement of typing-extensions to 4.5

Contributed by Patrick Arminio via PR #2872

0.187.0 - 2023-06-20

This release renames _type_definition to __strawberry_definition__. This doesn’t change the public API of Strawberry, but if you were using _type_definition you can still access it, but it will be removed in future.

Contributed by ניר via PR #2836

0.186.3 - 2023-06-20

This release adds resolve_async to NodeExtension to allow it to be used together with other field async extensions/permissions.

Contributed by Thiago Bellini Ribeiro via PR #2863

0.186.2 - 2023-06-19

This release fixes an issue on StrawberryField.copy_with method not copying its extensions and overwritten _arguments.

Also make sure that all lists/tuples in those types are copied as new lists/tuples to avoid unexpected behavior.

Contributed by Thiago Bellini Ribeiro via PR #2865

0.186.1 - 2023-06-16

In this release, we pass the default values from the strawberry.Schema through to the codegen plugins. The default python plugin now adds these default values to the objects it generates.

Contributed by Matt Gilson via PR #2860

0.186.0 - 2023-06-15

This release removes more parts of the Mypy plugin, since they are not needed anymore.

Contributed by Patrick Arminio via PR #2852

0.185.2 - 2023-06-15

This release fixes a bug causing a KeyError exception to be thrown during subscription cleanup.

Contributed by rjwills28 via PR #2794

0.185.1 - 2023-06-14

Correct a type-hinting bug with strawberry.directive. This may cause some consumers to have to remove a # type: ignore comment or unnecessary typing.cast in order to get mypy to pass.

Contributed by Matt Gilson via PR #2847

0.185.0 - 2023-06-14

This release removes our custom __dataclass_transform__ decorator and replaces it with typing-extension’s one. It also removes parts of the mypy plugin, since most of it is not needed anymore 🙌

This update requires typing_extensions>=4.1.0

Contributed by Patrick Arminio via PR #2227

0.184.1 - 2023-06-13

This release migrates our CLI to typer, all commands should work the same as before.

Contributed by Patrick Arminio via PR #2569

0.184.0 - 2023-06-12

This release improves the relay.NodeID annotation check by delaying it until after class initialization. This resolves issues with evaluating type annotations before they are fully defined and enables integrations to inject code for it in the type.

Contributed by Thiago Bellini Ribeiro via PR #2838

0.183.8 - 2023-06-12

This release fixes a bug in the codegen where List objects are currently emitted as Optional objects.

Contributed by Matt Gilson via PR #2843

0.183.7 - 2023-06-12

Refactor ConnectionExtension to copy arguments instead of extending them. This should fix some issues with integrations which override arguments, like the django one, where the inserted arguments were vanishing.

Contributed by Thiago Bellini Ribeiro via PR #2839

0.183.6 - 2023-06-09

This release fixes a bug where codegen would fail on mutations that have object arguments in the query.

Additionally, it does a topological sort of the types before passing it to the plugins to ensure that dependent types are defined after their dependencies.

Contributed by Matt Gilson via PR #2831

0.183.5 - 2023-06-08

This release fixes an issue where Strawberry would make copies of types that were using specialized generics that were not Strawerry types.

This issue combined with the use of lazy types was resulting in duplicated type errors.

Contributed by Patrick Arminio via PR #2824

0.183.4 - 2023-06-07

This release fixes an issue for parsing lazy types using forward references when they were enclosed in an Optional[...] type.

The following now should work properly:

from __future__ import annotations

from typing import Optional, Annotated
import strawberry


@strawberry.type
class MyType:
    other_type: Optional[Annotated["OtherType", strawberry.lazy("some.module")]]
    # or like this
    other_type: Annotated["OtherType", strawberry.lazy("some.module")] | None

Contributed by Thiago Bellini Ribeiro via PR #2821

0.183.3 - 2023-06-07

This release fixes a codegen bug. Prior to this fix, inline fragments would only include the last field defined within its scope and all fields common with its siblings.

After this fix, all fields will be included in the generated types.

Contributed by Matt Gilson via PR #2819

0.183.2 - 2023-06-07

Fields with generics support directives.

Contributed by A. Coady via PR #2811

0.183.1 - 2023-06-06

This release fixes an issue of the new relay integration adding an id: GlobalID! argument on all objects that inherit from relay.Node. That should’ve only happened for Query types.

Strawberry now will not force a relay.Node or any type that inherits it to be inject the node extension which adds the argument and a resolver for it, meaning that this code:

import strawberry
from strawberry import relay


@strawberry.type
class Fruit(relay.Node):
    id: relay.NodeID[int]


@strawberry.type
class Query:
    node: relay.Node
    fruit: Fruit

Should now be written as:

import strawberry
from strawberry import relay


@strawberry.type
class Fruit(relay.Node):
    id: relay.NodeID[int]


@strawberry.type
class Query:
    node: relay.Node = relay.node()  # <- note the "= relay.node()" here
    fruit: Fruit = relay.node()

Contributed by Thiago Bellini Ribeiro via PR #2814

0.183.0 - 2023-06-06

This release adds a new field extension called InputMutationExtension, which makes it easier to create mutations that receive a single input type called input, while still being able to define the arguments of that input on the resolver itself.

The following example:

import strawberry
from strawberry.field_extensions import InputMutationExtension


@strawberry.type
class Fruit:
    id: strawberry.ID
    name: str
    weight: float


@strawberry.type
class Mutation:
    @strawberry.mutation(extensions=[InputMutationExtension()])
    def update_fruit_weight(
        self,
        info: strawberry.Info,
        id: strawberry.ID,
        weight: Annotated[
            float,
            strawberry.argument(description="The fruit's new weight in grams"),
        ],
    ) -> Fruit:
        fruit = ...  # retrieve the fruit with the given ID
        fruit.weight = weight
        ...  # maybe save the fruit in the database
        return fruit

Would generate a schema like this:

input UpdateFruitInput {
  id: ID!

  """
  The fruit's new weight in grams
  """
  weight: Float!
}

type Fruit {
  id: ID!
  name: String!
  weight: Float!
}

type Mutation {
  updateFruitWeight(input: UpdateFruitInput!): Fruit!
}

Contributed by Thiago Bellini Ribeiro via PR #2580

0.182.0 - 2023-06-06

Initial relay spec implementation. For information on how to use it, check out the docs in here: https://strawberry.rocks/docs/guides/relay

Contributed by Thiago Bellini Ribeiro via PR #2511

0.181.0 - 2023-06-06

This release adds support for properly resolving lazy references when using forward refs.

For example, this code should now work without any issues:

from __future__ import annotations

from typing import TYPE_CHECKING, Annotated

if TYPE_CHECKING:
    from some.module import OtherType


@strawberry.type
class MyType:
    @strawberry.field
    async def other_type(
        self,
    ) -> Annotated[OtherType, strawberry.lazy("some.module")]: ...

Contributed by Thiago Bellini Ribeiro via PR #2744

0.180.5 - 2023-06-02

This release fixes a bug in fragment codegen to pick up type definitions from the proper place in the schema.

Contributed by Matt Gilson via PR #2805

0.180.4 - 2023-06-02

Custom codegen plugins will fail to write files if the plugin is trying to put the file anywhere other than the root output directory (since the child directories do not yet exist). This change will create the child directory if necessary before attempting to write the file.

Contributed by Matt Gilson via PR #2806

0.180.3 - 2023-06-02

This release updates the built-in GraphiQL to the current latest version 2.4.7 and improves styling for the GraphiQL Explorer Plugin.

Contributed by Kien Dang via PR #2804

0.180.2 - 2023-06-02

In this release codegen no longer chokes on queries that use a fragment.

There is one significant limitation at the present. When a fragment is included via the spread operator in an object, it must be the only field present. Attempts to include more fields will result in a ValueError.

However, there are some real benefits. When a fragment is included in multiple places in the query, only a single class will be made to represent that fragment:

fragment Point on Bar {
   id
   x
   y
}

query GetPoints {
  circlePoints {
    ...Point
  }
  squarePoints {
    ...Point
  }
}

Might generate the following types

class Point:
    id: str
    x: float
    y: float


class GetPointsResult:
    circle_points: List[Point]
    square_points: List[Point]

The previous behavior would generate duplicate classes for for the GetPointsCirclePoints and GetPointsSquarePoints even though they are really identical classes.

Contributed by Matt Gilson via PR #2802

0.180.1 - 2023-06-01

Make StrawberryAnnotation hashable, to make it compatible to newer versions of dacite.

Contributed by Jaime Coello de Portugal via PR #2790

0.180.0 - 2023-05-31

This release updates the Django Channels integration so that it uses the same base classes used by all other integrations.

New features:

The Django Channels integration supports two new features:

• Setting headers in a response
• File uploads via multipart/form-data POST requests

Breaking changes:

This release contains a breaking change for the Channels integration. The context object is now a dict and it contains different keys depending on the connection protocol:

1. HTTP: request and response. The request object contains the full request (including the body). Previously, request was the GraphQLHTTPConsumer instance of the current connection. The consumer is now available via request.consumer.
2. WebSockets: request, ws and response. request and ws are the same GraphQLWSConsumer instance of the current connection.

If you want to use a dataclass for the context object (like in previous releases), you can still use them by overriding the get_context methods. See the Channels integration documentation for an example.

Contributed by Christian Dröge via PR #2775

0.179.0 - 2023-05-31

This PR allows passing metadata to Strawberry arguments.

Example:

import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def hello(
        self,
        info,
        input: Annotated[str, strawberry.argument(metadata={"test": "foo"})],
    ) -> str:
        argument_definition = info.get_argument_definition("input")
        assert argument_definition.metadata["test"] == "foo"

        return f"Hi {input}"

Contributed by Jonathan Kim via PR #2755

0.178.3 - 2023-05-31

In this release codegen no longer chokes on queries that have a __typename in them. Python generated types will not have the __typename included in the fields.

Contributed by Matt Gilson via PR #2797

0.178.2 - 2023-05-31

Prevent AssertionError when using strawberry codegen on a query file that contains a mutation.

Contributed by Matt Gilson via PR #2795

0.178.1 - 2023-05-30

This release fixes a bug in experimental.pydantic whereby Optional type annotations weren’t exactly aligned between strawberry type and pydantic model.

Previously this would have caused the series field to be non-nullable in graphql.

from typing import Optional
from pydantic import BaseModel, Field
import strawberry


class VehicleModel(BaseModel):
    series: Optional[str] = Field(default="")


@strawberry.experimental.pydantic.type(model=VehicleModel, all_fields=True)
class VehicleModelType:
    pass

Contributed by Nick Butlin via PR #2782

0.178.0 - 2023-05-22

This release introduces the new should_ignore argument to the QueryDepthLimiter extension that provides a more general and more verbose way of specifying the rules by which a query’s depth should be limited.

The should_ignore argument should be a function that accepts a single argument of type IgnoreContext. The IgnoreContext class has the following attributes:

• field_name of type str: the name of the field to be compared against
• field_args of type strawberry.extensions.query_depth_limiter.FieldArgumentsType: the arguments of the field to be compared against
• query of type graphql.language.Node: the query string
• context of type graphql.validation.ValidationContext: the context passed to the query and returns True if the field should be ignored and False otherwise. This argument is injected, regardless of name, by the QueryDepthLimiter class and should not be passed by the user.

Instead, the user should write business logic to determine whether a field should be ignored or not by the attributes of the IgnoreContext class.

For example, the following query:

"""
    query {
      matt: user(name: "matt") {
        email
      }
      andy: user(name: "andy") {
        email
        address {
          city
        }
        pets {
          name
          owner {
            name
          }
        }
      }
    }
"""

can have its depth limited by the following should_ignore:

from strawberry.extensions import IgnoreContext


def should_ignore(ignore: IgnoreContext):
    return ignore.field_args.get("name") == "matt"


query_depth_limiter = QueryDepthLimiter(should_ignore=should_ignore)

so that it effectively becomes:

"""
    query {
      andy: user(name: "andy") {
        email
        pets {
          name
          owner {
            name
          }
        }
      }
    }
"""

Contributed by Tommy Smith via PR #2505

0.177.3 - 2023-05-19

This release adds a method on the DatadogTracingExtension class called create_span that can be overridden to create a custom span or add additional tags to the span.

from ddtrace import Span

from strawberry.extensions import LifecycleStep
from strawberry.extensions.tracing import DatadogTracingExtension


class DataDogExtension(DatadogTracingExtension):
    def create_span(
        self,
        lifecycle_step: LifecycleStep,
        name: str,
        **kwargs,
    ) -> Span:
        span = super().create_span(lifecycle_step, name, **kwargs)
        if lifecycle_step == LifeCycleStep.OPERATION:
            span.set_tag("graphql.query", self.execution_context.query)
        return span

Contributed by Ronald Williams via PR #2773

0.177.2 - 2023-05-18

This release fixes an issue with optional scalars using the or notation with forward references on python 3.10.

The following code would previously raise TypeError on python 3.10:

from __future__ import annotations

import strawberry
from strawberry.scalars import JSON


@strawberry.type
class SomeType:
    an_optional_json: JSON | None

Contributed by Thiago Bellini Ribeiro via PR #2774

0.177.1 - 2023-05-09

This release adds support for using enum_value with IntEnums, like this:

import strawberry

from enum import IntEnum


@strawberry.enum
class Color(IntEnum):
    OTHER = strawberry.enum_value(
        -1, description="Other: The color is not red, blue, or green."
    )
    RED = strawberry.enum_value(0, description="Red: The color red.")
    BLUE = strawberry.enum_value(1, description="Blue: The color blue.")
    GREEN = strawberry.enum_value(2, description="Green: The color green.")

Contributed by Patrick Arminio via PR #2761

0.177.0 - 2023-05-07

This release adds a SentryTracingExtension that you can use to automatically add tracing information to your GraphQL queries.

Contributed by Patrick Arminio via PR #2495

0.176.4 - 2023-05-07

This release adds support for custom classes inside the OpenTelemetry integration. With this, we shouldn’t see errors like this anymore:

Invalid type dict for attribute 'graphql.param.paginator' value. Expected one of ['bool', 'str', 'bytes', 'int', 'float'] or a sequence of those types.

Contributed by Budida Abhinav Ramana via PR #2753

0.176.3 - 2023-05-03

Add get_argument_definition helper function on the Info object to get a StrawberryArgument definition by argument name from inside a resolver or Field Extension.

Example:

import strawberry


@strawberry.type
class Query:
    @strawberry.field
    def field(
        self,
        info,
        my_input: Annotated[
            str,
            strawberry.argument(description="Some description"),
        ],
    ) -> str:
        my_input_def = info.get_argument_definition("my_input")
        assert my_input_def.type is str
        assert my_input_def.description == "Some description"

        return my_input

Contributed by Jonathan Kim via PR #2732

0.176.2 - 2023-05-02

This release adds more type hints to internal APIs and public APIs.

Contributed by Alex Auritt via PR #2568

0.176.1 - 2023-05-02

This release improves the graphql-transport-ws implementation by starting the sub-protocol timeout only when the connection handshake is completed.

Contributed by Kristján Valur Jónsson via PR #2703

0.176.0 - 2023-05-01

This release parses the input arguments to a field earlier so that Field Extensions recieve instances of Input types rather than plain dictionaries.

Example:

import strawberry
from strawberry.extensions import FieldExtension


@strawberry.input
class MyInput:
    foo: str


class MyFieldExtension(FieldExtension):
    def resolve(
        self, next_: Callable[..., Any], source: Any, info: strawberry.Info, **kwargs
    ):
        # kwargs["my_input"] is instance of MyInput
        ...


@strawberry.type
class Query:
    @strawberry.field
    def field(self, my_input: MyInput) -> str:
        return "hi"

Contributed by Jonathan Kim via PR #2731

0.175.1 - 2023-04-30

This release adds a missing parameter to get_context when using subscriptions with ASGI.

Contributed by Patrick Arminio via PR #2739

0.175.0 - 2023-04-29

Do not display graphiql view in fastapi doc if graphiql parameter is deactivated

Contributed by yak-toto via PR #2736

0.174.0 - 2023-04-25

This PR adds a MaxTokensLimiter extension which limits the number of tokens in a GraphQL document.

Usage example:

import strawberry
from strawberry.extensions import MaxTokensLimiter

schema = strawberry.Schema(
    Query,
    extensions=[
        MaxTokensLimiter(max_token_count=1000),
    ],
)

Contributed by reka via PR #2729

0.173.1 - 2023-04-25

This release bumps the version of typing_extensions to >= 4.0.0 to fix the error: "cannot import Self from typing_extensions".

Contributed by Tien Truong via PR #2704

0.173.0 - 2023-04-25

This releases adds an extension for PyInstrument. It allows to instrument your server and find slow code paths.

You can use it like this:

import strawberry
from strawberry.extensions import pyinstrument

schema = strawberry.Schema(
    Query,
    extensions=[
        pyinstrument.PyInstrument(report_path="pyinstrument.html"),
    ],
)

Contributed by Peyton Duncan via PR #2727

0.172.0 - 2023-04-24

This PR adds a MaxAliasesLimiter extension which limits the number of aliases in a GraphQL document.

Usage example:

import strawberry
from strawberry.extensions import MaxAliasesLimiter

schema = strawberry.Schema(
    Query,
    extensions=[
        MaxAliasesLimiter(max_alias_count=15),
    ],
)

Contributed by reka via PR #2726

0.171.3 - 2023-04-21

This release adds missing annotations in class methods, improving our type coverage.

Contributed by Kai Benevento via PR #2721

0.171.2 - 2023-04-21

graphql_transport_ws: Cancelling a subscription no longer blocks the connection while any subscription finalizers run.

Contributed by Kristján Valur Jónsson via PR #2718

0.171.1 - 2023-04-07

This release fix the return value of enums when using a custom name converter for them.

Contributed by Patrick Arminio via PR #2696

0.171.0 - 2023-04-06

This release adds support for Mypy 1.2.0

Contributed by Patrick Arminio via PR #2693

0.170.0 - 2023-04-06

This release add support for converting the enum value names from NameConverter. It looks like this:

from enum import Enum

import strawberry
from strawberry.enum import EnumDefinition, EnumValue
from strawberry.schema.config import StrawberryConfig
from strawberry.schema.name_converter import NameConverter


class EnumNameConverter(NameConverter):
    def from_enum_value(self, enum: EnumDefinition, enum_value: EnumValue) -> str:
        return f"{super().from_enum_value(enum, enum_value)}_enum_value"


@strawberry.enum
class MyEnum(Enum):
    A = "a"
    B = "b"


@strawberry.type
class Query:
    a_enum: MyEnum


schema = strawberry.Schema(
    query=Query,
    config=StrawberryConfig(name_converter=EnumNameConverter()),
)

Contributed by Patrick Arminio via PR #2690

0.169.0 - 2023-04-05

This release updates all* the HTTP integration to use the same base class, which makes it easier to maintain and extend them in future releases.

While this doesn’t provide any new features (other than settings headers in Chalice and Sanic), it does make it easier to extend the HTTP integrations in the future. So, expect some new features in the next releases!

New features:

Now both Chalice and Sanic integrations support setting headers in the response. Bringing them to the same level as the other HTTP integrations.

Breaking changes:

Unfortunately, this release does contain some breaking changes, but they are minimal and should be quick to fix.

1. Flask get_root_value and get_context now receive the request
2. Sanic get_root_value now receives the request and it is async

* The only exception is the channels http integration, which will be updated in a future release.

Contributed by Patrick Arminio via PR #2681

0.168.2 - 2023-04-03

Fixes type hint for StrawberryTypeFromPydantic._pydantic_type to be a Type instead of an instance of the Pydantic model. As it is a private API, we still highly discourage using it, but it’s now typed correctly.

from pydantic import BaseModel
from typing import Type, List

import strawberry
from strawberry.experimental.pydantic.conversion_types import StrawberryTypeFromPydantic


class User(BaseModel):
    name: str

    @staticmethod
    def foo() -> List[str]:
        return ["Patrick", "Pietro", "Pablo"]


@strawberry.experimental.pydantic.type(model=User, all_fields=True)
class UserType:
    @strawberry.field
    def foo(self: StrawberryTypeFromPydantic[User]) -> List[str]:
        # This is now inferred correctly as Type[User] instead of User
        # We still highly discourage using this private API, but it's
        # now typed correctly
        pydantic_type: Type[User] = self._pydantic_type
        return pydantic_type.foo()


def get_users() -> UserType:
    user: User = User(name="Patrick")
    return UserType.from_pydantic(user)


@strawberry.type
class Query:
    user: UserType = strawberry.field(resolver=get_users)


schema = strawberry.Schema(query=Query)

Contributed by James Chua via PR #2683

0.168.1 - 2023-03-26

This releases adds a new extra group for Starlite, preventing it from being installed by default.

Contributed by Patrick Arminio via PR #2664

0.168.0 - 2023-03-26

This release adds support for starlite.

import strawberry
from starlite import Request, Starlite
from strawberry.starlite import make_graphql_controller
from strawberry.types.info import Info


def custom_context_getter(request: Request):
    return {"custom": "context"}


@strawberry.type
class Query:
    @strawberry.field
    def hello(self, info: strawberry.Info[object, None]) -> str:
        return info.context["custom"]


schema = strawberry.Schema(Query)


GraphQLController = make_graphql_controller(
    schema,
    path="/graphql",
    context_getter=custom_context_getter,
)

app = Starlite(
    route_handlers=[GraphQLController],
)