feat(schema): semantic nullability draft

strawberry/annotation.py

@@ -18,12 +18,13 @@
     Union,
     cast,
 )
-from typing_extensions import Annotated, Self, get_args, get_origin
+from typing_extensions import Annotated, Required, Self, get_args, get_origin
 
 from strawberry.types.base import (
     StrawberryList,
     StrawberryObjectDefinition,
     StrawberryOptional,
+    StrawberryRequired,
     StrawberryTypeVar,
     get_object_definition,
     has_object_definition,
@@ -41,7 +42,6 @@
     from strawberry.types.field import StrawberryField
     from strawberry.types.union import StrawberryUnion
 
-
 ASYNC_TYPES = (
     abc.AsyncGenerator,
     abc.AsyncIterable,
@@ -160,6 +160,8 @@
             return self.create_enum(evaled_type)
         elif self._is_optional(evaled_type, args):
             return self.create_optional(evaled_type)
+        elif self._is_required(evaled_type):
+            return self.create_required(evaled_type)
         elif self._is_union(evaled_type, args):
             return self.create_union(evaled_type, args)
         elif is_type_var(evaled_type) or evaled_type is Self:
@@ -221,6 +223,18 @@
 
         return StrawberryOptional(of_type)
 
+    def create_required(self, evaled_type: Any) -> StrawberryRequired:
+        types = get_args(evaled_type)
+
+        child_type = Union[types]  # type: ignore
+
+        of_type = StrawberryAnnotation(
+            annotation=child_type,
+            namespace=self.namespace,
+        ).resolve()
+
+        return StrawberryRequired(of_type)
+
     def create_type_var(self, evaled_type: TypeVar) -> StrawberryTypeVar:
         return StrawberryTypeVar(evaled_type)
 
@@ -300,6 +314,12 @@
         # A Union to be optional needs to have at least one None type
         return any(x is type(None) for x in types)
 
+    @classmethod
+    def _is_required(cls, annotation: Any) -> bool:
+        """Returns True if the annotation is Required[SomeType]."""
+        # check if the annotation is typing.Required
+        return annotation is Required
+
     @classmethod
     def _is_list(cls, annotation: Any) -> bool:
         """Returns True if annotation is a List."""

strawberry/schema/config.py

@@ -15,6 +15,7 @@ class StrawberryConfig:
     default_resolver: Callable[[Any, str], object] = getattr
     relay_max_results: int = 100
     disable_field_suggestions: bool = False
+    semantic_nullability_beta: bool = False
     info_class: type[Info] = Info
 
     def __post_init__(

strawberry/schema/schema.py

@@ -168,7 +168,9 @@ class Query:
                 if has_object_definition(type_):
                     if type_.__strawberry_definition__.is_graphql_generic:
                         type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
-                graphql_type = self.schema_converter.from_maybe_optional(type_)
+                graphql_type = self.schema_converter.from_maybe_optional_or_required(
+                    type_
+                )
                 if isinstance(graphql_type, GraphQLNonNull):
                     graphql_type = graphql_type.of_type
                 if not isinstance(graphql_type, GraphQLNamedType):

strawberry/schema/schema_converter.py

@@ -58,6 +58,7 @@
     StrawberryList,
     StrawberryObjectDefinition,
     StrawberryOptional,
+    StrawberryRequired,
     StrawberryType,
     get_object_definition,
     has_object_definition,
@@ -72,6 +73,7 @@
 from strawberry.utils.await_maybe import await_maybe
 
 from ..extensions.field_extension import build_field_extension_resolvers
+from ..types.semantic_non_null import SemanticNonNull
 from . import compat
 from .types.concrete_type import ConcreteType
 
@@ -252,7 +254,7 @@
 
     def from_argument(self, argument: StrawberryArgument) -> GraphQLArgument:
         argument_type = cast(
-            "GraphQLInputType", self.from_maybe_optional(argument.type)
+            "GraphQLInputType", self.from_maybe_optional_or_required(argument.type)
         )
         default_value = Undefined if argument.default is UNSET else argument.default
 
@@ -367,6 +369,9 @@
             },
         )
 
+    def create_semantic_non_null_directive(self) -> SemanticNonNull:
+        return SemanticNonNull()
+
     def from_field(
         self,
         field: StrawberryField,
@@ -378,12 +383,19 @@
         resolver = self.from_resolver(field)
         field_type = cast(
             "GraphQLOutputType",
-            self.from_maybe_optional(
+            self.from_maybe_optional_or_required(
                 field.resolve_type(type_definition=type_definition)
             ),
         )
         subscribe = None
 
+        if (
+            self.config.semantic_nullability_beta
+            and isinstance(field_type, GraphQLNonNull)
+            and not getattr(field_type, "strawberry_semantic_required_non_null", False)
+        ):
+            field.directives.append(self.create_semantic_non_null_directive())
+
         if field.is_subscription:
             subscribe = resolver
             resolver = lambda event, *_, **__: event  # noqa: E731
@@ -413,7 +425,7 @@
     ) -> GraphQLInputField:
         field_type = cast(
             "GraphQLInputType",
-            self.from_maybe_optional(
+            self.from_maybe_optional_or_required(
                 field.resolve_type(type_definition=type_definition)
             ),
         )
@@ -586,7 +598,7 @@
         return graphql_interface
 
     def from_list(self, type_: StrawberryList) -> GraphQLList:
-        of_type = self.from_maybe_optional(type_.of_type)
+        of_type = self.from_maybe_optional_or_required(type_.of_type)
 
         return GraphQLList(of_type)
 
@@ -804,14 +816,18 @@
 
         return implementation
 
-    def from_maybe_optional(
+    def from_maybe_optional_or_required(
         self, type_: Union[StrawberryType, type]
     ) -> Union[GraphQLNullableType, GraphQLNonNull]:
+        #    ) -> Union[GraphQLNullableType, GraphQLNonNull, GraphQLSemanticNonNull]: TODO in the future this will include graphql semantic non null
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
         elif isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
+        elif isinstance(type_, StrawberryRequired):
+            graphql_core_type = GraphQLNonNull(self.from_type(type_))
+            graphql_core_type.strawberry_semantic_required_non_null = True
         else:
             return GraphQLNonNull(self.from_type(type_))
 

strawberry/types/base.py

@@ -163,6 +163,9 @@ class StrawberryList(StrawberryContainer): ...
 class StrawberryOptional(StrawberryContainer): ...
 
 
+class StrawberryRequired(StrawberryContainer): ...
+
+
 class StrawberryTypeVar(StrawberryType):
     def __init__(self, type_var: TypeVar) -> None:
         self.type_var = type_var

strawberry/types/semantic_non_null.py

@@ -0,0 +1,18 @@
+from strawberry.schema_directive import Location, schema_directive
+
+from .field import field
+
+
+@schema_directive(
+    locations=[
+        Location.FIELD_DEFINITION,
+        Location.OBJECT,
+        Location.INTERFACE,
+        Location.SCALAR,
+        Location.ENUM,
+    ],
+    name="semanticNonNull",
+    print_definition=True,
+)
+class SemanticNonNull:
+    levels: list[int] = field(default_factory=lambda: [1])

tests/schema/test_semantic_nullability.py

@@ -0,0 +1,63 @@
+import textwrap
+from typing import List, Optional, Required
+
+import strawberry
+from strawberry.schema.config import StrawberryConfig
+
+
+def test_entities_type_when_no_type_has_keys():
+    @strawberry.type()
+    class Product:
+        upc: str
+        name: str
+        price: Required[int]
+        weight: Optional[int]
+
+    @strawberry.federation.type(extend=True)
+    class Query:
+        @strawberry.field
+        def top_products(self, first: int) -> List[Product]:
+            return []
+
+    schema = strawberry.Schema(
+        query=Query, config=StrawberryConfig(semantic_nullability_beta=True)
+    )
+
+    expected_sdl = textwrap.dedent("""
+        type Product {
+          upc: String!
+          name: String
+          price: Int
+          weight: Int
+        }
+
+        extend type Query {
+          _service: _Service!
+          topProducts(first: Int!): [Product!]!
+        }
+
+        scalar _Any
+
+        type _Service {
+          sdl: String!
+        }
+    """).strip()
+
+    assert str(schema) == expected_sdl
+
+    query = """
+        query {
+            __type(name: "_Entity") {
+                kind
+                possibleTypes {
+                    name
+                }
+            }
+        }
+    """
+
+    result = schema.execute_sync(query)
+
+    assert not result.errors
+
+    assert result.data == {"__type": None}