Implement oneOf

RELEASE.md

@@ -0,0 +1,15 @@
+Release type: minor
+
+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.
+
+```python
+import strawberry
+
+
+@strawberry.input(one_of=True)
+class ExampleInputTagged:
+    a: str | None = strawberry.UNSET
+    b: int | None = strawberry.UNSET
+```

docs/types/input-types.md

@@ -102,3 +102,26 @@ Creates an input type from a class definition.
   generated by camel-casing the name of the class.
 - `description`: this is the GraphQL description that will be returned when
   introspecting the schema or when navigating the schema using GraphiQL.
+
+## One Of Input Types
+
+Strawberry also supports defining input types that can have only one field set.
+This is based on the
+[OneOf Input Objects RFC](https://github.com/graphql/graphql-spec/pull/825)
+
+To define a one of input type you can use the `one_of` flag on the
+`@strawberry.input` decorator:
+
+```python+schema
+import strawberry
+
+@strawberry.input(one_of=True)
+class SearchBy:
+    name: str | None = strawberry.UNSET
+    email: str | None = strawberry.UNSET
+---
+input SearchBy @oneOf {
+  name: String
+  email: String
+}
+```

strawberry/federation/object_type.py

@@ -31,6 +31,7 @@ def _impl_type(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Iterable[object] = (),
     authenticated: bool = False,
     keys: Iterable[Union["Key", str]] = (),
@@ -54,6 +55,7 @@ def _impl_type(
         Shareable,
         Tag,
     )
+    from strawberry.schema_directives import OneOf
 
     directives = list(directives)
 
@@ -83,6 +85,9 @@ def _impl_type(
     if is_interface_object:
         directives.append(InterfaceObject())
 
+    if one_of:
+        directives.append(OneOf())
+
     return base_type(  # type: ignore
         cls,
         name=name,
@@ -180,6 +185,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -197,6 +203,7 @@ def input(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
     tags: Iterable[str] = (),
@@ -207,6 +214,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -219,6 +227,7 @@ def input(
         directives=directives,
         inaccessible=inaccessible,
         is_input=True,
+        one_of=one_of,
         tags=tags,
     )
 

strawberry/object_type.py

@@ -293,6 +293,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> T: ...
@@ -305,6 +306,7 @@ def input(
 def input(
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> Callable[[T], T]: ...
@@ -314,6 +316,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ):
@@ -324,6 +327,11 @@ def input(
     >>>     field_abc: str = "ABC"
     """
 
+    from strawberry.schema_directives import OneOf
+
+    if one_of:
+        directives = (*(directives or ()), OneOf())
+
     return type(  # type: ignore # not sure why mypy complains here
         cls,
         name=name,

strawberry/schema/execute.py

@@ -23,6 +23,7 @@
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types import ExecutionResult
 
 from .exceptions import InvalidOperationTypeError
@@ -55,6 +56,10 @@ def validate_document(
     document: DocumentNode,
     validation_rules: Tuple[Type[ASTValidationRule], ...],
 ) -> List[GraphQLError]:
+    validation_rules = (
+        *validation_rules,
+        OneOfInputValidationRule,
+    )
     return validate(
         schema,
         document,

strawberry/schema/schema.py

@@ -16,6 +16,8 @@
 )
 
 from graphql import (
+    GraphQLBoolean,
+    GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
     GraphQLSchema,
@@ -168,6 +170,7 @@ def __init__(
 
         self._warn_for_federation_directives()
         self._resolve_node_ids()
+        self._extend_introspection()
 
         # Validate schema early because we want developers to know about
         # possible issues as soon as possible
@@ -375,6 +378,14 @@ def _warn_for_federation_directives(self):
                 stacklevel=3,
             )
 
+    def _extend_introspection(self):
+        def _resolve_is_one_of(obj: Any, info: Any) -> bool:
+            return obj.extensions["strawberry-definition"].is_one_of
+
+        instrospection_type = self._schema.type_map["__Type"]
+        instrospection_type.fields["isOneOf"] = GraphQLField(GraphQLBoolean)  # type: ignore[attr-defined]
+        instrospection_type.fields["isOneOf"].resolve = _resolve_is_one_of  # type: ignore[attr-defined]
+
     def as_str(self) -> str:
         return print_schema(self)
 

strawberry/schema/schema_converter.py

@@ -26,6 +26,7 @@
     GraphQLDirective,
     GraphQLEnumType,
     GraphQLEnumValue,
+    GraphQLError,
     GraphQLField,
     GraphQLInputField,
     GraphQLInputObjectType,
@@ -409,13 +410,35 @@ def from_input_object(self, object_type: type) -> GraphQLInputObjectType:
             assert isinstance(graphql_object_type, GraphQLInputObjectType)  # For mypy
             return graphql_object_type
 
+        def check_one_of(value: dict[str, Any]) -> dict[str, Any]:
+            if len(value) != 1:
+                raise GraphQLError(
+                    f"OneOf Input Object '{type_name}' must specify exactly one key."
+                )
+
+            first_key, first_value = next(iter(value.items()))
+
+            if first_value is None or first_value is UNSET:
+                raise GraphQLError(
+                    f"Value for member field '{first_key}' must be non-null"
+                )
+
+            return value
+
+        out_type = (
+            check_one_of
+            if type_definition.is_input and type_definition.is_one_of
+            else None
+        )
+
         graphql_object_type = GraphQLInputObjectType(
             name=type_name,
             fields=lambda: self.get_graphql_input_fields(type_definition),
             description=type_definition.description,
             extensions={
                 GraphQLCoreConverter.DEFINITION_BACKREF: type_definition,
             },
+            out_type=out_type,
         )
 
         self.type_map[type_name] = ConcreteType(

strawberry/schema/validation_rules/one_of.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from graphql import (
+    ExecutableDefinitionNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    VariableDefinitionNode,
+    get_named_type,
+)
+
+
+class OneOfInputValidationRule(ValidationRule):
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_operation_definition(
+        self, node: ExecutableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions: dict[str, VariableDefinitionNode] = {}
+
+    def enter_variable_definition(
+        self, node: VariableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions[node.variable.name.value] = node
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        type_ = get_named_type(self.context.get_input_type())
+
+        if not type_:
+            return
+
+        strawberry_type = type_.extensions.get("strawberry-definition")
+
+        if strawberry_type and strawberry_type.is_one_of:
+            self.validate_one_of(node, type_)
+
+    def validate_one_of(self, node: ObjectValueNode, type: GraphQLNamedType) -> None:
+        field_node_map = {field.name.value: field for field in node.fields}
+        keys = list(field_node_map.keys())
+        is_not_exactly_one_field = len(keys) != 1
+
+        if is_not_exactly_one_field:
+            self.report_error(
+                GraphQLError(
+                    f"OneOf Input Object '{type.name}' must specify exactly one key.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        value = field_node_map[keys[0]].value
+        is_null_literal = not value or value.kind == "null_value"
+        is_variable = value.kind == "variable"
+
+        if is_null_literal:
+            self.report_error(
+                GraphQLError(
+                    f"Field '{type.name}.{keys[0]}' must be non-null.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        if is_variable:
+            variable_name = value.name.value  # type: ignore
+            definition = self.variable_definitions[variable_name]
+            is_nullable_variable = definition.type.kind != "non_null_type"
+
+            if is_nullable_variable:
+                self.report_error(
+                    GraphQLError(
+                        f"Variable '{variable_name}' must be non-nullable to be used for OneOf Input Object '{type.name}'.",
+                        nodes=[node],
+                    )
+                )

strawberry/schema_directives.py

@@ -0,0 +1,8 @@
+from strawberry.schema_directive import Location, schema_directive
+
+
+@schema_directive(locations=[Location.INPUT_OBJECT], name="oneOf")
+class OneOf: ...
+
+
+__all__ = ["OneOf"]

strawberry/type.py

@@ -37,6 +37,10 @@ class StrawberryType(ABC):
     def type_params(self) -> List[TypeVar]:
         return []
 
+    @property
+    def is_one_of(self) -> bool:
+        return False
+
     @abstractmethod
     def copy_with(
         self,

strawberry/types/types.py

@@ -197,6 +197,15 @@ def is_implemented_by(self, root: Type[WithStrawberryObjectDefinition]) -> bool:
         # All field mappings succeeded. This is a match
         return True
 
+    @property
+    def is_one_of(self) -> bool:
+        from strawberry.schema_directives import OneOf
+
+        if not self.is_input or not self.directives:
+            return False
+
+        return any(isinstance(directive, OneOf) for directive in self.directives)
+
 
 # TODO: remove when deprecating _type_definition
 if TYPE_CHECKING:

tests/federation/printer/test_one_of.py

@@ -0,0 +1,45 @@
+import textwrap
+from typing import Optional
+
+import strawberry
+
+
+def test_prints_one_of_directive():
+    @strawberry.federation.input(one_of=True, tags=["myTag", "anotherTag"])
+    class Input:
+        a: Optional[str] = strawberry.UNSET
+        b: Optional[int] = strawberry.UNSET
+
+    @strawberry.federation.type
+    class Query:
+        hello: str
+
+    schema = strawberry.federation.Schema(
+        query=Query, types=[Input], enable_federation_2=True
+    )
+
+    expected = """
+        directive @oneOf on INPUT_OBJECT
+
+        schema @link(url: "https://specs.apollo.dev/federation/v2.7", import: ["@tag"]) {
+          query: Query
+        }
+
+        input Input @tag(name: "myTag") @tag(name: "anotherTag") @oneOf {
+          a: String
+          b: Int
+        }
+
+        type Query {
+          _service: _Service!
+          hello: String!
+        }
+
+        scalar _Any
+
+        type _Service {
+          sdl: String!
+        }
+    """
+
+    assert schema.as_str() == textwrap.dedent(expected).strip()