CHANGELOG

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.type s 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 IntEnum s, 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],
)

Contributed by Matthieu MN via PR #2391

0.167.1 - 2023-03-26

This release fixes and issue where you'd get a warning about using Apollo Federation directives even when using strawberry.federation.Schema .

Contributed by Patrick Arminio via PR #2661

0.167.0 - 2023-03-25

This releases adds more type annotations for public functions and methods.

No new changes have been added to the API.

Contributed by Jad Haddad via PR #2627

0.166.0 - 2023-03-25

This release adds a warning when using @strawberry.federation.type but not using strawberry.federation.Schema

Contributed by Rubens O Leão via PR #2572

0.165.1 - 2023-03-21

Updates the MaskErrors extension to the new extension API, which was missed previously.

Contributed by Nikolai Maas via PR #2655

0.165.0 - 2023-03-18

Add full support for forward references, specially when using from __future__ import annotations .

Before the following would fail on python versions older than 3.10:

from __future__ import annotations

import strawberry


@strawberry.type
class Query:
    foo: str | None

Also, this would fail in any python versions:

from __future__ import annotations

from typing import Annotated

import strawberry


@strawberry.type
class Query:
    foo: Annotated[str, "some annotation"]

Now both of these cases are supported. Please open an issue if you find any edge cases that are still not supported.

Contributed by Thiago Bellini Ribeiro via PR #2592

0.164.1 - 2023-03-18

Fix interface duplication leading to schema compilation error in multiple inheritance scenarios (i.e. "Diamond Problem" inheritance)

Thank you @mzhu22 for the thorough bug report!

Contributed by San Kilkis via PR #2647

0.164.0 - 2023-03-14

This release introduces a breaking change to make pydantic default behavior consistent with normal strawberry types. This changes the schema generated for pydantic types, that are required, and have default values. Previously pydantic type with a default, would get converted to a strawberry type that is not required. This is now fixed, and the schema will now correctly show the type as required.

import pydantic
import strawberry


class UserPydantic(pydantic.BaseModel):
    name: str = "James"


@strawberry.experimental.pydantic.type(UserPydantic, all_fields=True)
class User: ...


@strawberry.type
class Query:
    a: User = strawberry.field()

    @strawberry.field
    def a(self) -> User:
        return User()

The schema is now

type Query {
  a: User!
}

type User {
  name: String! // String! rather than String previously
}

Contributed by James Chua via PR #2623

0.163.2 - 2023-03-14

This release covers an edge case where the following would not give a nice error.

some_field: "Union[list[str], SomeType]]"

Fixes #2591

Contributed by ניר via PR #2593

0.163.1 - 2023-03-14

Provide close reason to ASGI websocket as specified by ASGI 2.3

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

0.163.0 - 2023-03-13

This release adds support for list arguments in operation directives.

The following is now supported:

@strawberry.directive(locations=[DirectiveLocation.FIELD])
def append_names(
    value: DirectiveValue[str], names: List[str]
):  # note the usage of List here
    return f"{value} {', '.join(names)}"

Contributed by chenyijian via PR #2632

0.162.0 - 2023-03-10

Adds support for a custom field using the approach specified in issue #2168 . Field Extensions may be used to change the way how fields work and what they return. Use cases might include pagination, permissions or other behavior modifications.

from strawberry.extensions import FieldExtension


class UpperCaseExtension(FieldExtension):
    async def resolve_async(
        self,
        next: Callable[..., Awaitable[Any]],
        source: Any,
        info: strawberry.Info,
        **kwargs
    ):
        result = await next(source, info, **kwargs)
        return str(result).upper()


@strawberry.type
class Query:
    @strawberry.field(extensions=[UpperCaseExtension()])
    async def string(self) -> str:
        return "This is a test!!"

query {
    string
}

{
  "string": "THIS IS A TEST!!"
}

Contributed by Erik Wrede via PR #2567

0.161.1 - 2023-03-09

Ensure that no other messages follow a "complete" or "error" message for an operation in the graphql-transport-ws protocol.

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

0.161.0 - 2023-03-08

Calling ChannelsConsumer.channel_listen multiple times will now pass along the messages being listened for to multiple callers, rather than only one of the callers, which was the old behaviour.

This resolves an issue where creating multiple GraphQL subscriptions using a single websocket connection could result in only one of those subscriptions (in a non-deterministic order) being triggered if they are listening for channel layer messages of the same type.

Contributed by James Thorniley via PR #2525

0.160.0 - 2023-03-08

Rename Extension to SchemaExtension to pave the way for FieldExtensions. Importing Extension from strawberry.extensions will now raise a deprecation warning.

Before:

from strawberry.extensions import Extension

After:

from strawberry.extensions import SchemaExtension

Contributed by Jonathan Kim via PR #2574

0.159.1 - 2023-03-07

This releases adds support for Mypy 1.1.1

Contributed by Patrick Arminio via PR #2616

0.159.0 - 2023-02-22

This release changes how extension hooks are defined. The new style hooks are more flexible and allow to run code before and after the execution.

The old style hooks are still supported but will be removed in future releases.

Before:

def on_executing_start(self):  # Called before the execution start
    ...


def on_executing_end(self):  # Called after the execution ends
    ...

After

def on_execute(self):
    #  This part is called before the execution start
    yield
    #  This part is called after the execution ends

Contributed by ניר via PR #2428

0.158.2 - 2023-02-21

Add a type annotation to strawberry.fastapi.BaseContext ’s __init__ method so that it can be used without mypy raising an error.

Contributed by Martin Winkel via PR #2581

0.158.1 - 2023-02-19

Version 1.5.10 of GraphiQL disabled introspection for deprecated arguments because it wasn’t supported by all GraphQL server versions. This PR enables it so that deprecated arguments show up again in GraphiQL.

Contributed by Jonathan Kim via PR #2575

0.158.0 - 2023-02-18

Throw proper exceptions when Unions are created with invalid types

Previously, using Lazy types inside of Unions would raise unexpected, unhelpful errors.

Contributed by ignormies via PR #2540

0.157.0 - 2023-02-18

This releases adds support for Apollo Federation 2.1, 2.2 and 2.3.

This includes support for @composeDirective and @interfaceObject , we expose directives for both, but we also have shortcuts, for example to use @composeDirective with a custom schema directive, you can do the following:

@strawberry.federation.schema_directive(
    locations=[Location.OBJECT], name="cacheControl", compose=True
)
class CacheControl:
    max_age: int

The compose=True makes so that this directive is included in the supergraph schema.

For @interfaceObject we introduced a new @strawberry.federation.interface_object decorator. This works like @strawberry.federation.type , but it adds, the appropriate directive, for example:

@strawberry.federation.interface_object(keys=["id"])
class SomeInterface:
    id: strawberry.ID

generates the following type:

type SomeInterface @key(fields: "id") @interfaceObject {
  id: ID!
}

Contributed by Patrick Arminio via PR #2549

0.156.4 - 2023-02-13

This release fixes a regression introduce in version 0.156.2 that would make Mypy throw an error in the following code:

import strawberry


@strawberry.type
class Author:
    name: str


@strawberry.type
class Query:
    @strawberry.field
    async def get_authors(self) -> list[Author]:
        return [Author(name="Michael Crichton")]