strawberry-graphql 0.220.0.dev1709543239__py3-none-any.whl → 0.221.0.dev1710955937__py3-none-any.whl

strawberry/channels/testing.py

@@ -69,6 +69,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         path: str,
         headers: Optional[List[Tuple[bytes, bytes]]] = None,
         protocol: str = GRAPHQL_TRANSPORT_WS_PROTOCOL,
+        connection_params: dict = {},
         **kwargs: Any,
     ):
         """
@@ -81,6 +82,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         self.protocol = protocol
         subprotocols = kwargs.get("subprotocols", [])
         subprotocols.append(protocol)
+        self.connection_params = connection_params
         super().__init__(application, path, headers, subprotocols=subprotocols)
 
     async def __aenter__(self) -> Self:
@@ -99,7 +101,9 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         res = await self.connect()
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             assert res == (True, GRAPHQL_TRANSPORT_WS_PROTOCOL)
-            await self.send_json_to(ConnectionInitMessage().as_dict())
+            await self.send_json_to(
+                ConnectionInitMessage(payload=self.connection_params).as_dict()
+            )
             response = await self.receive_json_from()
             assert response == ConnectionAckMessage().as_dict()
         else:

strawberry/schema/execute.py

@@ -88,82 +88,77 @@ async def execute(
         extensions=list(extensions),
     )
 
-    try:
-        async with extensions_runner.operation():
-            # Note: In graphql-core the schema would be validated here but in
-            # Strawberry we are validating it at initialisation time instead
-            if not execution_context.query:
-                raise MissingQueryError()
-
-            async with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
-
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=await extensions_runner.get_extensions_results(),
+    async with extensions_runner.operation():
+        # Note: In graphql-core the schema would be validated here but in
+        # Strawberry we are validating it at initialisation time instead
+        if not execution_context.query:
+            raise MissingQueryError()
+
+        async with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    execution_context.graphql_document = parse_document(
+                        execution_context.query, **execution_context.parse_options
                     )
 
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
-
-            async with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
-
-            async with extensions_runner.executing():
-                if not execution_context.result:
-                    result = original_execute(
-                        schema,
-                        execution_context.graphql_document,
-                        root_value=execution_context.root_value,
-                        middleware=extensions_runner.as_middleware_manager(),
-                        variable_values=execution_context.variables,
-                        operation_name=execution_context.operation_name,
-                        context_value=execution_context.context,
-                        execution_context_class=execution_context_class,
-                    )
-
-                    if isawaitable(result):
-                        result = await cast(Awaitable["GraphQLExecutionResult"], result)
-
-                    result = cast("GraphQLExecutionResult", result)
-                    execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
-                    # to access in extensions
-                    if result.errors:
-                        execution_context.errors = result.errors
-
-                        # Run the `Schema.process_errors` function here before
-                        # extensions have a chance to modify them (see the MaskErrors
-                        # extension). That way we can log the original errors but
-                        # only return a sanitised version to the client.
-                        process_errors(result.errors, execution_context)
-
-    except (MissingQueryError, InvalidOperationTypeError) as e:
-        raise e
-    except Exception as exc:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=[error],
-            extensions=await extensions_runner.get_extensions_results(),
-        )
+            except GraphQLError as error:
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=await extensions_runner.get_extensions_results(),
+                )
+
+            except Exception as error:  # pragma: no cover
+                error = GraphQLError(str(error), original_error=error)
+
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=await extensions_runner.get_extensions_results(),
+                )
+
+        if execution_context.operation_type not in allowed_operation_types:
+            raise InvalidOperationTypeError(execution_context.operation_type)
+
+        async with extensions_runner.validation():
+            _run_validation(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
+
+        async with extensions_runner.executing():
+            if not execution_context.result:
+                result = original_execute(
+                    schema,
+                    execution_context.graphql_document,
+                    root_value=execution_context.root_value,
+                    middleware=extensions_runner.as_middleware_manager(),
+                    variable_values=execution_context.variables,
+                    operation_name=execution_context.operation_name,
+                    context_value=execution_context.context,
+                    execution_context_class=execution_context_class,
+                )
+
+                if isawaitable(result):
+                    result = await cast(Awaitable["GraphQLExecutionResult"], result)
+
+                result = cast("GraphQLExecutionResult", result)
+                execution_context.result = result
+                # Also set errors on the execution_context so that it's easier
+                # to access in extensions
+                if result.errors:
+                    execution_context.errors = result.errors
+
+                    # Run the `Schema.process_errors` function here before
+                    # extensions have a chance to modify them (see the MaskErrors
+                    # extension). That way we can log the original errors but
+                    # only return a sanitised version to the client.
+                    process_errors(result.errors, execution_context)
 
     return ExecutionResult(
         data=execution_context.result.data,
@@ -186,86 +181,80 @@ def execute_sync(
         extensions=list(extensions),
     )
 
-    try:
-        with extensions_runner.operation():
-            # Note: In graphql-core the schema would be validated here but in
-            # Strawberry we are validating it at initialisation time instead
-            if not execution_context.query:
-                raise MissingQueryError()
-
-            with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
-
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=extensions_runner.get_extensions_results_sync(),
+    with extensions_runner.operation():
+        # Note: In graphql-core the schema would be validated here but in
+        # Strawberry we are validating it at initialisation time instead
+        if not execution_context.query:
+            raise MissingQueryError()
+
+        with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    execution_context.graphql_document = parse_document(
+                        execution_context.query, **execution_context.parse_options
                     )
 
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
-
-            with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
-
-            with extensions_runner.executing():
-                if not execution_context.result:
-                    result = original_execute(
-                        schema,
-                        execution_context.graphql_document,
-                        root_value=execution_context.root_value,
-                        middleware=extensions_runner.as_middleware_manager(),
-                        variable_values=execution_context.variables,
-                        operation_name=execution_context.operation_name,
-                        context_value=execution_context.context,
-                        execution_context_class=execution_context_class,
+            except GraphQLError as error:
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=extensions_runner.get_extensions_results_sync(),
+                )
+
+            except Exception as error:  # pragma: no cover
+                error = GraphQLError(str(error), original_error=error)
+
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=extensions_runner.get_extensions_results_sync(),
+                )
+
+        if execution_context.operation_type not in allowed_operation_types:
+            raise InvalidOperationTypeError(execution_context.operation_type)
+
+        with extensions_runner.validation():
+            _run_validation(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
+
+        with extensions_runner.executing():
+            if not execution_context.result:
+                result = original_execute(
+                    schema,
+                    execution_context.graphql_document,
+                    root_value=execution_context.root_value,
+                    middleware=extensions_runner.as_middleware_manager(),
+                    variable_values=execution_context.variables,
+                    operation_name=execution_context.operation_name,
+                    context_value=execution_context.context,
+                    execution_context_class=execution_context_class,
+                )
+
+                if isawaitable(result):
+                    result = cast(Awaitable["GraphQLExecutionResult"], result)
+                    ensure_future(result).cancel()
+                    raise RuntimeError(
+                        "GraphQL execution failed to complete synchronously."
                     )
 
-                    if isawaitable(result):
-                        result = cast(Awaitable["GraphQLExecutionResult"], result)
-                        ensure_future(result).cancel()
-                        raise RuntimeError(
-                            "GraphQL execution failed to complete synchronously."
-                        )
-
-                    result = cast("GraphQLExecutionResult", result)
-                    execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
-                    # to access in extensions
-                    if result.errors:
-                        execution_context.errors = result.errors
-
-                        # Run the `Schema.process_errors` function here before
-                        # extensions have a chance to modify them (see the MaskErrors
-                        # extension). That way we can log the original errors but
-                        # only return a sanitised version to the client.
-                        process_errors(result.errors, execution_context)
-
-    except (MissingQueryError, InvalidOperationTypeError) as e:
-        raise e
-    except Exception as exc:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=[error],
-            extensions=extensions_runner.get_extensions_results_sync(),
-        )
+                result = cast("GraphQLExecutionResult", result)
+                execution_context.result = result
+                # Also set errors on the execution_context so that it's easier
+                # to access in extensions
+                if result.errors:
+                    execution_context.errors = result.errors
+
+                    # Run the `Schema.process_errors` function here before
+                    # extensions have a chance to modify them (see the MaskErrors
+                    # extension). That way we can log the original errors but
+                    # only return a sanitised version to the client.
+                    process_errors(result.errors, execution_context)
 
     return ExecutionResult(
         data=execution_context.result.data,

strawberry/schema_codegen/__init__.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import keyword
+from collections import defaultdict
+from typing import TYPE_CHECKING, Tuple
+from typing_extensions import Protocol
 
 import libcst as cst
 from graphql import (
@@ -19,6 +22,7 @@ from graphql import (
     OperationType,
     ScalarTypeDefinitionNode,
     SchemaDefinitionNode,
+    SchemaExtensionNode,
     StringValueNode,
     TypeNode,
     UnionTypeDefinitionNode,
@@ -27,6 +31,14 @@ from graphql import (
 
 from strawberry.utils.str_converters import to_snake_case
 
+if TYPE_CHECKING:
+    from graphql.language.ast import ConstDirectiveNode
+
+
+class HasDirectives(Protocol):
+    directives: Tuple[ConstDirectiveNode]
+
+
 _SCALAR_MAP = {
     "Int": cst.Name("int"),
     "Float": cst.Name("float"),
@@ -48,6 +60,19 @@ _SCALAR_MAP = {
 }
 
 
+def _is_federation_link_directive(directive: ConstDirectiveNode) -> bool:
+    if directive.name.value != "link":
+        return False
+
+    for argument in directive.arguments:
+        if argument.name.value == "url":
+            return argument.value.value.startswith(
+                "https://specs.apollo.dev/federation"
+            )
+
+    return False
+
+
 def _get_field_type(
     field_type: TypeNode, was_non_nullable: bool = False
 ) -> cst.BaseExpression:
@@ -85,7 +110,10 @@ def _get_field_type(
     )
 
 
-def _get_argument(name: str, value: str) -> cst.Arg:
+def _sanitize_argument(value: str | bool) -> cst.SimpleString | cst.Name:
+    if isinstance(value, bool):
+        return cst.Name(value=str(value))
+
     if "\n" in value:
         argument_value = cst.SimpleString(f'"""\n{value}\n"""')
     elif '"' in value:
@@ -93,6 +121,12 @@ def _get_argument(name: str, value: str) -> cst.Arg:
     else:
         argument_value = cst.SimpleString(f'"{value}"')
 
+    return argument_value
+
+
+def _get_argument(name: str, value: str | bool) -> cst.Arg:
+    argument_value = _sanitize_argument(value)
+
     return cst.Arg(
         value=argument_value,
         keyword=cst.Name(name),
@@ -100,7 +134,25 @@ def _get_argument(name: str, value: str) -> cst.Arg:
     )
 
 
-def _get_field_value(description: str | None, alias: str | None) -> cst.Call | None:
+def _get_argument_list(name: str, values: list[str]) -> cst.Arg:
+    value = cst.List(
+        elements=[cst.Element(value=_sanitize_argument(value)) for value in values],
+    )
+
+    return cst.Arg(
+        value=value,
+        keyword=cst.Name(name),
+        equal=cst.AssignEqual(cst.SimpleWhitespace(""), cst.SimpleWhitespace("")),
+    )
+
+
+def _get_field_value(
+    field: FieldDefinitionNode | InputValueDefinitionNode,
+    alias: str | None,
+    is_apollo_federation: bool,
+) -> cst.Call | None:
+    description = field.description.value if field.description else None
+
     args = list(
         filter(
             None,
@@ -111,6 +163,24 @@ def _get_field_value(description: str | None, alias: str | None) -> cst.Call | N
         )
     )
 
+    directives = _get_directives(field)
+
+    apollo_federation_args = _get_federation_arguments(directives)
+
+    if is_apollo_federation and apollo_federation_args:
+        args.extend(apollo_federation_args)
+
+        return cst.Call(
+            func=cst.Attribute(
+                value=cst.Attribute(
+                    value=cst.Name("strawberry"),
+                    attr=cst.Name("federation"),
+                ),
+                attr=cst.Name("field"),
+            ),
+            args=args,
+        )
+
     if args:
         return cst.Call(
             func=cst.Attribute(
@@ -125,6 +195,7 @@ def _get_field_value(description: str | None, alias: str | None) -> cst.Call | N
 
 def _get_field(
     field: FieldDefinitionNode | InputValueDefinitionNode,
+    is_apollo_federation: bool,
 ) -> cst.SimpleStatementLine:
     name = to_snake_case(field.name.value)
     alias: str | None = None
@@ -141,19 +212,67 @@ def _get_field(
                     _get_field_type(field.type),
                 ),
                 value=_get_field_value(
-                    description=field.description.value if field.description else None,
-                    alias=alias if alias != name else None,
+                    field, alias=alias, is_apollo_federation=is_apollo_federation
                 ),
             )
         ]
     )
 
 
+def _get_directives(definition: HasDirectives) -> dict[str, list[dict[str, str]]]:
+    directives = defaultdict(list)
+
+    for directive in definition.directives:
+        directive_name = directive.name.value
+
+        directives[directive_name].append(
+            {
+                argument.name.value: argument.value.value
+                for argument in directive.arguments
+            }
+        )
+
+    return directives
+
+
+def _get_federation_arguments(
+    directives: dict[str, list[dict[str, str]]],
+) -> list[cst.Arg]:
+    def append_arg_from_directive(
+        directive: str, argument_name: str, keyword_name: str | None = None
+    ):
+        keyword_name = keyword_name or directive
+
+        if directive in directives:
+            arguments.append(
+                _get_argument_list(
+                    keyword_name,
+                    [item[argument_name] for item in directives[directive]],
+                )
+            )
+
+    arguments: list[cst.Arg] = []
+
+    append_arg_from_directive("key", "fields", "keys")
+    append_arg_from_directive("requires", "fields")
+    append_arg_from_directive("provides", "fields")
+    append_arg_from_directive("tag", "name", "tags")
+
+    boolean_keys = ("shareable", "inaccessible", "external", "override")
+
+    arguments.extend(
+        _get_argument(key, True) for key in boolean_keys if directives.get(key, False)
+    )
+
+    return arguments
+
+
 def _get_strawberry_decorator(
     definition: ObjectTypeDefinitionNode
     | ObjectTypeExtensionNode
     | InterfaceTypeDefinitionNode
     | InputObjectTypeDefinitionNode,
+    is_apollo_federation: bool,
 ) -> cst.Decorator:
     type_ = {
         ObjectTypeDefinitionNode: "type",
@@ -168,15 +287,36 @@ def _get_strawberry_decorator(
         else None
     )
 
+    directives = _get_directives(definition)
+
     decorator: cst.BaseExpression = cst.Attribute(
         value=cst.Name("strawberry"),
         attr=cst.Name(type_),
     )
 
+    arguments: list[cst.Arg] = []
+
     if description is not None:
+        arguments.append(_get_argument("description", description.value))
+
+    federation_arguments = _get_federation_arguments(directives)
+
+    # and has any directive that is a federation directive
+    if is_apollo_federation and federation_arguments:
+        decorator = cst.Attribute(
+            value=cst.Attribute(
+                value=cst.Name("strawberry"),
+                attr=cst.Name("federation"),
+            ),
+            attr=cst.Name(type_),
+        )
+
+        arguments.extend(federation_arguments)
+
+    if arguments:
         decorator = cst.Call(
             func=decorator,
-            args=[_get_argument("description", description.value)],
+            args=arguments,
         )
 
     return cst.Decorator(
@@ -189,8 +329,9 @@ def _get_class_definition(
     | ObjectTypeExtensionNode
     | InterfaceTypeDefinitionNode
     | InputObjectTypeDefinitionNode,
+    is_apollo_federation: bool,
 ) -> cst.ClassDef:
-    decorator = _get_strawberry_decorator(definition)
+    decorator = _get_strawberry_decorator(definition, is_apollo_federation)
 
     bases = (
         [cst.Arg(cst.Name(interface.name.value)) for interface in definition.interfaces]
@@ -204,7 +345,11 @@ def _get_class_definition(
     return cst.ClassDef(
         name=cst.Name(definition.name.value),
         bases=bases,
-        body=cst.IndentedBlock(body=[_get_field(field) for field in definition.fields]),
+        body=cst.IndentedBlock(
+            body=[
+                _get_field(field, is_apollo_federation) for field in definition.fields
+            ]
+        ),
         decorators=[decorator],
     )
 
@@ -243,6 +388,7 @@ def _get_schema_definition(
     root_query_name: str | None,
     root_mutation_name: str | None,
     root_subscription_name: str | None,
+    is_apollo_federation: bool,
 ) -> cst.SimpleStatementLine | None:
     if not any([root_query_name, root_mutation_name, root_subscription_name]):
         return None
@@ -265,17 +411,40 @@ def _get_schema_definition(
     if root_subscription_name:
         args.append(_get_arg("subscription", root_subscription_name))
 
+    schema_call = cst.Call(
+        func=cst.Attribute(
+            value=cst.Name("strawberry"),
+            attr=cst.Name("Schema"),
+        ),
+        args=args,
+    )
+
+    if is_apollo_federation:
+        args.append(
+            cst.Arg(
+                keyword=cst.Name("enable_federation_2"),
+                value=cst.Name("True"),
+                equal=cst.AssignEqual(
+                    cst.SimpleWhitespace(""), cst.SimpleWhitespace("")
+                ),
+            )
+        )
+        schema_call = cst.Call(
+            func=cst.Attribute(
+                value=cst.Attribute(
+                    value=cst.Name(value="strawberry"),
+                    attr=cst.Name(value="federation"),
+                ),
+                attr=cst.Name(value="Schema"),
+            ),
+            args=args,
+        )
+
     return cst.SimpleStatementLine(
         body=[
             cst.Assign(
                 targets=[cst.AssignTarget(cst.Name("schema"))],
-                value=cst.Call(
-                    func=cst.Attribute(
-                        value=cst.Name("strawberry"),
-                        attr=cst.Name("Schema"),
-                    ),
-                    args=args,
-                ),
+                value=schema_call,
             )
         ]
     )
@@ -430,6 +599,12 @@ def codegen(schema: str) -> str:
 
     object_types: dict[str, cst.ClassDef] = {}
 
+    # when we encounter a extend schema @link ..., we check if is an apollo federation schema
+    # and we use this variable to keep track of it, but at the moment the assumption is that
+    # the schema extension is always done at the top, this might not be the case all the
+    # time
+    is_apollo_federation = False
+
     for definition in document.definitions:
         if isinstance(
             definition,
@@ -440,7 +615,7 @@ def codegen(schema: str) -> str:
                 ObjectTypeExtensionNode,
             ),
         ):
-            class_definition = _get_class_definition(definition)
+            class_definition = _get_class_definition(definition, is_apollo_federation)
 
             object_types[definition.name.value] = class_definition
 
@@ -478,6 +653,11 @@ def codegen(schema: str) -> str:
                 definitions.append(cst.EmptyLine())
                 definitions.append(scalar_definition)
                 definitions.append(cst.EmptyLine())
+        elif isinstance(definition, SchemaExtensionNode):
+            is_apollo_federation = any(
+                _is_federation_link_directive(directive)
+                for directive in definition.directives
+            )
         else:
             raise NotImplementedError(f"Unknown definition {definition}")
 
@@ -496,6 +676,7 @@ def codegen(schema: str) -> str:
         root_query_name=root_query_name,
         root_mutation_name=root_mutation_name,
         root_subscription_name=root_subscription_name,
+        is_apollo_federation=is_apollo_federation,
     )
 
     if schema_definition:

{strawberry_graphql-0.220.0.dev1709543239.dist-info → strawberry_graphql-0.221.0.dev1710955937.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.220.0.dev1709543239
+Version: 0.221.0.dev1710955937
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.220.0.dev1709543239.dist-info → strawberry_graphql-0.221.0.dev1710955937.dist-info}/RECORD

@@ -25,7 +25,7 @@ strawberry/channels/handlers/graphql_ws_handler.py,sha256=PHRkwnXt3tY4E0XBVHh4hp
 strawberry/channels/handlers/http_handler.py,sha256=9pW978XaeF-aFWM9WMaSHCOWmcWoIJCNkW8X3lKJcws,9560
 strawberry/channels/handlers/ws_handler.py,sha256=sHL44eay4tNoKzkrRn3WewSYH-3ZSJzxJpmBJ-aTkeM,4650
 strawberry/channels/router.py,sha256=dyOBbSF8nFiygP0zz6MM14mhkvFQAEbbLBXzcpubSHM,1927
-strawberry/channels/testing.py,sha256=he9cdsu5KxoPfpR8z2E6kwr2hwUjVhACTrTIoIbsSkQ,5519
+strawberry/channels/testing.py,sha256=IWj1CuIS3vOo2f2fw0W-0GCz-YSs7QSAAscC6suqtiI,5668
 strawberry/cli/__init__.py,sha256=OkUYNyurO-TyHcD_RsP1bjtNrxlM5gV6Ri6vs4asvvc,374
 strawberry/cli/app.py,sha256=tTMBV1pdWqMcwjWO2yn-8oLDhMhfJvUzyQtWs75LWJ0,54
 strawberry/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -186,7 +186,7 @@ strawberry/schema/base.py,sha256=lQBJyzG2ZhKc544oLbXEbpYOPOjaXBop3lxp68h_lfI,297
 strawberry/schema/compat.py,sha256=n0r3UPUcGemMqK8vklgtCkkuCA1p6tWAYbc6Vl4iNOw,1684
 strawberry/schema/config.py,sha256=N9KsqkSTnm5snizoBZAVneaWQprhaTd8PFyMuR-jfUs,632
 strawberry/schema/exceptions.py,sha256=_9Ua-lLRCJfbtd8B6MXILNKGI2SwHkcBNkAHYM7ITp8,534
-strawberry/schema/execute.py,sha256=6OE7_5v4G3t_wxp1_mfwu8TTiIkTJNBQaeGCVAljUYw,10982
+strawberry/schema/execute.py,sha256=MAfuE2o89qBmnBpgaTmUA9xJ682KvEQw52EOh4XVE00,10415
 strawberry/schema/name_converter.py,sha256=UdNyd-QtqF2HsDCQK-nsOcLGxDTj4hJwYFNvMtZnpq4,6533
 strawberry/schema/schema.py,sha256=HvdOmXK2yHCliD-xyAV01rw3PoGW2f8oEzOYo-cA0AM,13726
 strawberry/schema/schema_converter.py,sha256=r5T0mwM4qY51yq_0bWDKRqeod9hzJJg3OGzV8siXnRU,34730
@@ -194,7 +194,7 @@ strawberry/schema/types/__init__.py,sha256=oHO3COWhL3L1KLYCJNY1XFf5xt2GGtHiMC-Ua
 strawberry/schema/types/base_scalars.py,sha256=Z_BmgwLicNexLipGyw6MmZ7OBnkGJU3ySgaY9SwBWrw,1837
 strawberry/schema/types/concrete_type.py,sha256=HB30G1hMUuuvjAvfSe6ADS35iI_T_wKO-EprVOWTMSs,746
 strawberry/schema/types/scalar.py,sha256=SVJ8HiKncCvOw2xwABI5xYaHcC7KkGHG-tx2WDtSoCA,2802
-strawberry/schema_codegen/__init__.py,sha256=U-ABa02BAfCN6zEGlc2LJEju18ErtGjbf0S8BhJXc6w,15592
+strawberry/schema_codegen/__init__.py,sha256=bPWBUwYPGYRtLwLu1QtDWa0Knt0IgF0FcZnePvDkveI,20837
 strawberry/schema_directive.py,sha256=GxiOedFB-RJAflpQNUZv00C5Z6gavR-AYdsvoCA_0jc,1963
 strawberry/starlite/__init__.py,sha256=v209swT8H9MljVL-npvANhEO1zz3__PSfxb_Ix-NoeE,134
 strawberry/starlite/controller.py,sha256=x6Mm3r36cRfzo6hz9B4AYWbVh2QlYtndYcXFOr_3THM,11860
@@ -241,8 +241,8 @@ strawberry/utils/logging.py,sha256=flS7hV0JiIOEdXcrIjda4WyIWix86cpHHFNJL8gl1y4,7
 strawberry/utils/operation.py,sha256=Um-tBCPl3_bVFN2Ph7o1mnrxfxBes4HFCj6T0x4kZxE,1135
 strawberry/utils/str_converters.py,sha256=avIgPVLg98vZH9mA2lhzVdyyjqzLsK2NdBw9mJQ02Xk,813
 strawberry/utils/typing.py,sha256=Qxz1LwyVsNGV7LQW1dFsaUbsswj5LHBOdKLMom5eyEA,13491
-strawberry_graphql-0.220.0.dev1709543239.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.220.0.dev1709543239.dist-info/METADATA,sha256=jkAZjN8RDuaeEREHhENLaroXtadRJqyEHGmu1PGHaHI,7754
-strawberry_graphql-0.220.0.dev1709543239.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-strawberry_graphql-0.220.0.dev1709543239.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.220.0.dev1709543239.dist-info/RECORD,,
+strawberry_graphql-0.221.0.dev1710955937.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.221.0.dev1710955937.dist-info/METADATA,sha256=l7sfrGtQwOGjYGDh5RVMKFg7bL4dvPYKnTzz6xo-eFU,7754
+strawberry_graphql-0.221.0.dev1710955937.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+strawberry_graphql-0.221.0.dev1710955937.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.221.0.dev1710955937.dist-info/RECORD,,