strawberry-graphql 0.278.1__py3-none-any.whl → 0.279.0__py3-none-any.whl

strawberry/cli/commands/upgrade/__init__.py

@@ -10,6 +10,7 @@ from libcst.codemod import CodemodContext
 
 from strawberry.cli.app import app
 from strawberry.codemods.annotated_unions import ConvertUnionToAnnotatedUnion
+from strawberry.codemods.maybe_optional import ConvertMaybeToOptional
 from strawberry.codemods.update_imports import UpdateImportsCodemod
 
 from ._run_codemod import run_codemod
@@ -17,6 +18,7 @@ from ._run_codemod import run_codemod
 codemods = {
     "annotated-union": ConvertUnionToAnnotatedUnion,
     "update-imports": UpdateImportsCodemod,
+    "maybe-optional": ConvertMaybeToOptional,
 }
 
 

strawberry/codemods/__init__.py

@@ -0,0 +1,9 @@
+from .annotated_unions import ConvertUnionToAnnotatedUnion
+from .maybe_optional import ConvertMaybeToOptional
+from .update_imports import UpdateImportsCodemod
+
+__all__ = [
+    "ConvertMaybeToOptional",
+    "ConvertUnionToAnnotatedUnion",
+    "UpdateImportsCodemod",
+]

strawberry/codemods/maybe_optional.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import libcst as cst
+import libcst.matchers as m
+from libcst._nodes.expression import BaseExpression  # noqa: TC002
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+from libcst.codemod.visitors import AddImportsVisitor
+
+
+class ConvertMaybeToOptional(VisitorBasedCodemodCommand):
+    DESCRIPTION: str = (
+        "Converts strawberry.Maybe[T] to strawberry.Maybe[T | None] "
+        "to match the new Maybe type definition"
+    )
+
+    def __init__(
+        self,
+        context: CodemodContext,
+        use_pipe_syntax: bool = True,  # Default to pipe syntax for modern Python
+    ) -> None:
+        self.use_pipe_syntax = use_pipe_syntax
+        super().__init__(context)
+
+    @m.leave(
+        m.Subscript(
+            value=m.Attribute(value=m.Name("strawberry"), attr=m.Name("Maybe"))
+            | m.Name("Maybe")
+        )
+    )
+    def leave_maybe_subscript(
+        self, original_node: cst.Subscript, updated_node: cst.Subscript
+    ) -> BaseExpression:
+        # Skip if it's not a strawberry.Maybe or imported Maybe
+        if isinstance(original_node.value, cst.Name):
+            # Check if this is an imported Maybe from strawberry
+            # For now, we'll assume any standalone "Maybe" is from strawberry
+            # In a more robust implementation, we'd track imports
+            pass
+
+        # Get the inner type
+        if isinstance(original_node.slice, (list, tuple)):
+            if len(original_node.slice) != 1:
+                return original_node
+            slice_element = original_node.slice[0]
+        else:
+            slice_element = original_node.slice
+
+        if not isinstance(slice_element, cst.SubscriptElement):
+            return original_node
+
+        if not isinstance(slice_element.slice, cst.Index):
+            return original_node
+
+        inner_type = slice_element.slice.value
+
+        # Check if the inner type already includes None
+        if self._already_includes_none(inner_type):
+            return original_node
+
+        # Create the new union type with None
+        new_type: BaseExpression
+        if self.use_pipe_syntax:
+            new_type = cst.BinaryOperation(
+                left=inner_type,
+                operator=cst.BitOr(
+                    whitespace_before=cst.SimpleWhitespace(" "),
+                    whitespace_after=cst.SimpleWhitespace(" "),
+                ),
+                right=cst.Name("None"),
+            )
+        else:
+            # Use Union[T, None] syntax
+            AddImportsVisitor.add_needed_import(self.context, "typing", "Union")
+            new_type = cst.Subscript(
+                value=cst.Name("Union"),
+                slice=[
+                    cst.SubscriptElement(slice=cst.Index(value=inner_type)),
+                    cst.SubscriptElement(slice=cst.Index(value=cst.Name("None"))),
+                ],
+            )
+
+        # Return the updated Maybe[T | None]
+        return updated_node.with_changes(
+            slice=[cst.SubscriptElement(slice=cst.Index(value=new_type))]
+        )
+
+    def _already_includes_none(self, node: BaseExpression) -> bool:
+        """Check if the type already includes None (e.g., T | None or Union[T, None])."""
+        # Check for T | None pattern
+        if isinstance(node, cst.BinaryOperation) and isinstance(
+            node.operator, cst.BitOr
+        ):
+            if isinstance(node.right, cst.Name) and node.right.value == "None":
+                return True
+            # Recursively check left side for chained unions
+            if self._already_includes_none(node.left):
+                return True
+
+        # Check for Union[..., None] pattern
+        if (
+            isinstance(node, cst.Subscript)
+            and isinstance(node.value, cst.Name)
+            and node.value.value == "Union"
+        ):
+            # Handle both list and tuple slice formats
+            slice_elements = (
+                node.slice if isinstance(node.slice, (list, tuple)) else [node.slice]
+            )
+            for element in slice_elements:
+                if (
+                    isinstance(element, cst.SubscriptElement)
+                    and isinstance(element.slice, cst.Index)
+                    and isinstance(element.slice.value, cst.Name)
+                    and element.slice.value.value == "None"
+                ):
+                    return True
+
+        return False

strawberry/schema/schema.py

@@ -50,6 +50,7 @@ from strawberry.extensions.directives import (
 from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
+from strawberry.schema.validation_rules.maybe_null import MaybeNullValidationRule
 from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types.base import (
     StrawberryObjectDefinition,
@@ -124,6 +125,7 @@ def validate_document(
 ) -> list[GraphQLError]:
     validation_rules = (
         *validation_rules,
+        MaybeNullValidationRule,
         OneOfInputValidationRule,
     )
     return validate(

strawberry/schema/schema_converter.py

@@ -854,6 +854,13 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
+        if isinstance(type_, StrawberryMaybe):
+            # StrawberryMaybe should always generate optional types
+            # because Maybe[T] = Union[Some[T], None] (field can be absent)
+            # But we need to handle the case where of_type is itself optional
+            if isinstance(type_.of_type, StrawberryOptional):
+                return self.from_type(type_.of_type.of_type)
+            return self.from_type(type_.of_type)
         if isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
         return GraphQLNonNull(self.from_type(type_))

strawberry/schema/validation_rules/maybe_null.py

@@ -0,0 +1,136 @@
+from typing import Any
+
+from graphql import (
+    ArgumentNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    get_named_type,
+)
+
+from strawberry.types.base import StrawberryMaybe, StrawberryOptional
+from strawberry.utils.str_converters import to_camel_case
+
+
+class MaybeNullValidationRule(ValidationRule):
+    """Validates that Maybe[T] fields do not receive explicit null values.
+
+    This rule ensures that:
+    - Maybe[T] fields can only be omitted or have non-null values
+    - Maybe[T | None] fields can be omitted, null, or have non-null values
+
+    This provides clear semantics where Maybe[T] means "either present with value or absent"
+    and Maybe[T | None] means "present with value, present but null, or absent".
+    """
+
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_argument(self, node: ArgumentNode, *_args: Any) -> None:
+        # Check if this is a null value
+        if node.value.kind != "null_value":
+            return
+
+        # Get the argument definition from the schema
+        argument_def = self.context.get_argument()
+        if not argument_def:
+            return
+
+        # Check if this argument corresponds to a Maybe[T] (not Maybe[T | None])
+        # The argument type extensions should contain the Strawberry type info
+        strawberry_arg_info = argument_def.extensions.get("strawberry-definition")
+        if not strawberry_arg_info:
+            return
+
+        # Get the Strawberry type from the argument info
+        field_type = getattr(strawberry_arg_info, "type", None)
+        if not field_type:
+            return
+
+        if isinstance(field_type, StrawberryMaybe) and not isinstance(
+            field_type.of_type, StrawberryOptional
+        ):
+            # This is Maybe[T] - should not accept null values
+            type_name = self._get_type_name(field_type.of_type)
+
+            self.report_error(
+                GraphQLError(
+                    f"Expected value of type '{type_name}', found null. "
+                    f"Argument '{node.name.value}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                    f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                    nodes=[node],
+                )
+            )
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        # Get the input type for this object
+        input_type = get_named_type(self.context.get_input_type())
+        if not input_type:
+            return
+
+        # Get the Strawberry type definition from extensions
+        strawberry_type = input_type.extensions.get("strawberry-definition")
+        if not strawberry_type:
+            return
+
+        # Check each field in the object for null Maybe[T] violations
+        self.validate_maybe_fields(node, input_type, strawberry_type)
+
+    def validate_maybe_fields(
+        self, node: ObjectValueNode, input_type: GraphQLNamedType, strawberry_type: Any
+    ) -> None:
+        # Create a map of field names to field nodes for easy lookup
+        field_node_map = {field.name.value: field for field in node.fields}
+
+        # Check each field in the Strawberry type definition
+        if not hasattr(strawberry_type, "fields"):
+            return
+
+        for field_def in strawberry_type.fields:
+            # Resolve the actual GraphQL field name using the same logic as NameConverter
+            if field_def.graphql_name is not None:
+                field_name = field_def.graphql_name
+            else:
+                # Apply auto_camel_case conversion if enabled (default behavior)
+                field_name = to_camel_case(field_def.python_name)
+
+            # Check if this field is present in the input and has a null value
+            if field_name in field_node_map:
+                field_node = field_node_map[field_name]
+
+                # Check if this field has a null value
+                if field_node.value.kind == "null_value":
+                    # Check if this is a Maybe[T] (not Maybe[T | None])
+                    field_type = field_def.type
+                    if isinstance(field_type, StrawberryMaybe) and not isinstance(
+                        field_type.of_type, StrawberryOptional
+                    ):
+                        # This is Maybe[T] - should not accept null values
+                        type_name = self._get_type_name(field_type.of_type)
+                        self.report_error(
+                            GraphQLError(
+                                f"Expected value of type '{type_name}', found null. "
+                                f"Field '{field_name}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                                f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                                nodes=[field_node],
+                            )
+                        )
+
+    def _get_type_name(self, type_: Any) -> str:
+        """Get a readable type name for error messages."""
+        if hasattr(type_, "__name__"):
+            return type_.__name__
+        # Handle Strawberry types that don't have __name__
+        if hasattr(type_, "of_type") and hasattr(type_.of_type, "__name__"):
+            # For StrawberryList, StrawberryOptional, etc.
+            return (
+                f"list[{type_.of_type.__name__}]"
+                if "List" in str(type_.__class__)
+                else type_.of_type.__name__
+            )
+        return str(type_)
+
+
+__all__ = ["MaybeNullValidationRule"]

strawberry/types/arguments.py

@@ -191,10 +191,24 @@ def convert_argument(
     from strawberry.relay.types import GlobalID
 
     # TODO: move this somewhere else and make it first class
-    if isinstance(type_, StrawberryOptional):
+    # Handle StrawberryMaybe first, since it extends StrawberryOptional
+    if isinstance(type_, StrawberryMaybe):
+        # Check if this is Maybe[T | None] (has StrawberryOptional as of_type)
+        if isinstance(type_.of_type, StrawberryOptional):
+            # This is Maybe[T | None] - allows null values
+            res = convert_argument(value, type_.of_type, scalar_registry, config)
+
+            return Some(res)
+
+        # This is Maybe[T] - validation for null values is handled by MaybeNullValidationRule
+        # Convert the value and wrap in Some()
         res = convert_argument(value, type_.of_type, scalar_registry, config)
 
-        return Some(res) if isinstance(type_, StrawberryMaybe) else res
+        return Some(res)
+
+    # Handle regular StrawberryOptional (not Maybe)
+    if isinstance(type_, StrawberryOptional):
+        return convert_argument(value, type_.of_type, scalar_registry, config)
 
     if value is None:
         return None

strawberry/types/maybe.py

@@ -31,7 +31,7 @@ class Some(Generic[T]):
 
 
 if TYPE_CHECKING:
-    Maybe: TypeAlias = Union[Some[Union[T, None]], None]
+    Maybe: TypeAlias = Union[Some[T], None]
 else:
     # we do this trick so we can inspect that at runtime
     class Maybe(Generic[T]): ...

{strawberry_graphql-0.278.1.dist-info → strawberry_graphql-0.279.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.278.1
+Version: 0.279.0
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.278.1.dist-info → strawberry_graphql-0.279.0.dist-info}/RECORD

@@ -25,7 +25,7 @@ strawberry/cli/commands/export_schema.py,sha256=pyp_Q3BiO7lFH0L3mNPvr7UF8hlhcoUP
 strawberry/cli/commands/locate_definition.py,sha256=aJJ_KeAnV-c8zTdWIhzcHUilUmCpqsmrVy24qHbyWKk,1001
 strawberry/cli/commands/schema_codegen.py,sha256=G6eV08a51sjVxCm3jn75oPn9hC8YarKiAKOY5bpTuKU,749
 strawberry/cli/commands/server.py,sha256=qj5wn22HvyJDzwnWzduIWRnS912XvD7GRhPGJkbLaz4,2217
-strawberry/cli/commands/upgrade/__init__.py,sha256=nY_Cj4yOj3CVdzEPWMAgof-dIr804sEJ-cCVOfI6UWo,2480
+strawberry/cli/commands/upgrade/__init__.py,sha256=yj7OxtXhvYdV-P072VFrLnbQmtREnYMLn7iku8gap6k,2596
 strawberry/cli/commands/upgrade/_fake_progress.py,sha256=fefLgJwTXe4kG9RntdEJdzkPPRBK_pZqnmMH-pxD85Y,484
 strawberry/cli/commands/upgrade/_run_codemod.py,sha256=LZd5D1PP65bwVZjBvPPVrZ9t-bfvrafZ__HPBrW2WYA,2168
 strawberry/cli/constants.py,sha256=GhhDZOl9lN4glq50OI1oSbPSGqQXEarZ6r_Grq8pcpI,138
@@ -40,8 +40,9 @@ strawberry/codegen/plugins/python.py,sha256=GgwxTGd16LPKxGuZBohJYWsarKjWfZY1-aGI
 strawberry/codegen/plugins/typescript.py,sha256=LFEK2ZLz4tUukkwZvUTXhsi_cVca3ybsLaatsW5JA5g,3865
 strawberry/codegen/query_codegen.py,sha256=F5z-6qK5KcagagBcZvnjx6iIvdJol17DsBQt7TqhCH4,30539
 strawberry/codegen/types.py,sha256=K5sjzNWDefOzdGtPumXyLuhnlEtd0zZXdPkF15lejk0,4181
-strawberry/codemods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strawberry/codemods/__init__.py,sha256=iXL0fq_VMhmSN3NFkQC4IwQn3pscfES61icODcJAjeo,268
 strawberry/codemods/annotated_unions.py,sha256=T0KqJEmoOdOXVCOHI1G6ECvEVL2tzIRBenysrz3EhPQ,5988
+strawberry/codemods/maybe_optional.py,sha256=PnFbh4kax7UMrsMOsqMF55Q3NN6jMPMxfs_25KmlB_A,4401
 strawberry/codemods/update_imports.py,sha256=4n1m-mxVK7h4FnkrpWgxOOCswIqy9SisApWbh-oSZ3E,4622
 strawberry/dataloader.py,sha256=W4wC-qKrljeKZKH8OgEoGDN_M8aIyhCBLA6g7x04vRQ,7867
 strawberry/directive.py,sha256=GFFUJSuvvr8BV7gRa1XveYIeekuuxlauCpYA9GJonlE,3584
@@ -172,13 +173,14 @@ strawberry/schema/compat.py,sha256=xNpOEDfi-MODpplMGaKuKeQIVcr-tcAaKaU3TlBc1Zs,1
 strawberry/schema/config.py,sha256=bkEMn0EkBRg2Tl6ZZH5hpOGBNiAw9QcOclt5dI_Yd1g,1217
 strawberry/schema/exceptions.py,sha256=8gsMxxFDynMvRkUDuVL9Wwxk_zsmo6QoJ2l4NPxd64M,1137
 strawberry/schema/name_converter.py,sha256=JG5JKLr9wp8BMJIvG3_bVkwFdoLGbknNR1Bt75urXN0,6950
-strawberry/schema/schema.py,sha256=EZ6YLV5wqHrjxi3rVJ0HvbGeIlZrbSOZqEomKlu4-OY,39433
-strawberry/schema/schema_converter.py,sha256=ZGkZjLsqjZ-0y5NItsECHZbOOhjJioYRT6YROwmo4Gg,40125
+strawberry/schema/schema.py,sha256=Tg-_hC2ri0ibM-gncOEsLkTmt5T3HM6UsetfYPa1t4M,39548
+strawberry/schema/schema_converter.py,sha256=pxp2cz5ZWQV7k_FPWKHXOHpvgR_5aXAFQuCluNhWwvQ,40566
 strawberry/schema/types/__init__.py,sha256=oHO3COWhL3L1KLYCJNY1XFf5xt2GGtHiMC-UaYbFfnA,68
 strawberry/schema/types/base_scalars.py,sha256=JRUq0WjEkR9dFewstZnqnZKp0uOEipo4UXNF5dzRf4M,1971
 strawberry/schema/types/concrete_type.py,sha256=axIyFZgdwNv-XYkiqX67464wuFX6Vp0jYATwnBZSUvM,750
 strawberry/schema/types/scalar.py,sha256=bg9AumdmYUBuvaKoEZtP9YKJ7lwMtDMCWFTsZQwpdQY,2375
 strawberry/schema/validation_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strawberry/schema/validation_rules/maybe_null.py,sha256=RrIq1yV5_2YxIYN7jx8AaY6O_pqxKtylbM1IygFz5z4,5624
 strawberry/schema/validation_rules/one_of.py,sha256=fPuYzCyLT7p9y7dHF_sWTImArTQaEhyF664lZijB1Gw,2629
 strawberry/schema_codegen/__init__.py,sha256=mN4Qmu5Iakht6nHpRpt9hCs8e--oTPlVtDJZJpzgHR4,24364
 strawberry/schema_directive.py,sha256=CbjdX54EIeWGkJu4SgiLR8mph5_8wyNsgJk2oLoQK_0,2023
@@ -201,7 +203,7 @@ strawberry/tools/__init__.py,sha256=pdGpZx8wpq03VfUZJyF9JtYxZhGqzzxCiipsalWxJX4,
 strawberry/tools/create_type.py,sha256=y10LgJnWDFtZB-xHLqpVg5ySqvz5KSFC6PNflogie1Q,2329
 strawberry/tools/merge_types.py,sha256=hUMRRNM28FyPp70jRA3d4svv9WoEBjaNpihBt3DaY0I,1023
 strawberry/types/__init__.py,sha256=baWEdDkkmCcITOhkg2hNUOenrNV1OYdxGE5qgvIRwwU,351
-strawberry/types/arguments.py,sha256=Qe3bpKjJWsrN7Qh9kOr0ZjrwDVc_nb2VFWqL22XJ4II,11129
+strawberry/types/arguments.py,sha256=5Rw_gAVEw1tkBQJuzeYUahAqMGoZU7JwUf4zAME2vqg,11779
 strawberry/types/auto.py,sha256=WZ2cQAI8nREUigBzpzFqIKGjJ_C2VqpAPNe8vPjTciM,3007
 strawberry/types/base.py,sha256=Bfa-5Wen8qR7m6tlSMRRGlGE-chRGMHjQMopfNdbbrk,15197
 strawberry/types/cast.py,sha256=fx86MkLW77GIximBAwUk5vZxSGwDqUA6XicXvz8EXwQ,916
@@ -213,7 +215,7 @@ strawberry/types/fields/resolver.py,sha256=b6lxfw6AMOUFWm7vs7a9KzNkpR8b_S110DoIo
 strawberry/types/graphql.py,sha256=gXKzawwKiow7hvoJhq5ApNJOMUCnKmvTiHaKY5CK1Lw,867
 strawberry/types/info.py,sha256=V3DQMd97tkWSdPIhp7HcelQ2h94-HSCI5zJ7cRO7i58,4907
 strawberry/types/lazy_type.py,sha256=dlP9VcMjZc9sdgriiQGzOZa0TToB6Ee7zpIP8h7TLC0,5079
-strawberry/types/maybe.py,sha256=Zdv4pAJwgUmaFNU8WKlwjk50qwgYEzT90WteURZBzAo,1174
+strawberry/types/maybe.py,sha256=3TEY0S2qT_unEdYlPUW50HBuOIIaploZVy3JWpXdeeE,1161
 strawberry/types/mutation.py,sha256=cg-_O2WWnZ-GSwOIv0toSdxlGeY2lhBBxZ24AifJuSM,11978
 strawberry/types/nodes.py,sha256=RwZB43OT9BS3Cqjgq4AazqOfyq_y0GD2ysC86EDBv5U,5134
 strawberry/types/object_type.py,sha256=SdJF2RWDIrh0C99rEW64rbxMaLokG-J8NLybSqkUrcE,15766
@@ -236,8 +238,8 @@ strawberry/utils/logging.py,sha256=U1cseHGquN09YFhFmRkiphfASKCyK0HUZREImPgVb0c,7
 strawberry/utils/operation.py,sha256=ZgVOw3K2jQuLjNOYUHauF7itJD0QDNoPw9PBi0IYf6k,1234
 strawberry/utils/str_converters.py,sha256=-eH1Cl16IO_wrBlsGM-km4IY0IKsjhjnSNGRGOwQjVM,897
 strawberry/utils/typing.py,sha256=SDvX-Du-9HAV3-XXjqi7Q5f5qPDDFd_gASIITiwBQT4,14073
-strawberry_graphql-0.278.1.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.278.1.dist-info/METADATA,sha256=r90Q-i1R-Ulf5SsQvJZoNUoW-N3TZkK-jMmj8od9ZGs,7426
-strawberry_graphql-0.278.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-strawberry_graphql-0.278.1.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.278.1.dist-info/RECORD,,
+strawberry_graphql-0.279.0.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.279.0.dist-info/METADATA,sha256=NJmXqmdIsIc9ea2XTmGqBcbNycy2Y1cGljd30GV-KN4,7426
+strawberry_graphql-0.279.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+strawberry_graphql-0.279.0.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.279.0.dist-info/RECORD,,