feature: Adds FragmentsOnCompositeTypesRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/FragmentsOnCompositeTypesRule.swift

@@ -0,0 +1,52 @@
+
+/**
+ * Fragments on composite type
+ *
+ * Fragments use a type condition to determine if they apply, since fragments
+ * can only be spread into a composite type (object, interface, or union), the
+ * type condition must also be a composite type.
+ *
+ * See https://spec.graphql.org/draft/#sec-Fragments-On-Composite-Types
+ */
+func FragmentsOnCompositeTypesRule(context: ValidationContext) -> Visitor {
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if let fragment = node as? InlineFragment {
+                if let typeCondition = fragment.typeCondition {
+                    if let type = typeFromAST(schema: context.schema, inputTypeAST: typeCondition) {
+                        if type is GraphQLCompositeType {
+                            return .continue
+                        }
+                        let typeStr = typeCondition.name.value
+                        context.report(
+                            error: GraphQLError(
+                                message:
+                                "Fragment cannot condition on non composite type \"\(typeStr)\".",
+                                nodes: [typeCondition]
+                            )
+                        )
+                    }
+                }
+                return .continue
+            }
+            if let fragment = node as? FragmentDefinition {
+                let typeCondition = fragment.typeCondition
+                if let type = typeFromAST(schema: context.schema, inputTypeAST: typeCondition) {
+                    if type is GraphQLCompositeType {
+                        return .continue
+                    }
+                    let typeStr = typeCondition.name.value
+                    context.report(
+                        error: GraphQLError(
+                            message:
+                            "Fragment \"\(fragment.name.value)\" cannot condition on non composite type \"\(typeStr)\".",
+                            nodes: [typeCondition]
+                        )
+                    )
+                }
+                return .continue
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -7,7 +7,7 @@ public let specifiedRules: [(ValidationContext) -> Visitor] = [
     LoneAnonymousOperationRule,
 //    SingleFieldSubscriptionsRule,
     KnownTypeNamesRule,
-//    FragmentsOnCompositeTypesRule,
+    FragmentsOnCompositeTypesRule,
 //    VariablesAreInputTypesRule,
     ScalarLeafsRule,
     FieldsOnCorrectTypeRule,

Tests/GraphQLTests/ValidationTests/FragmentsOnCompositeTypesRuleTests.swift

@@ -0,0 +1,144 @@
+@testable import GraphQL
+import XCTest
+
+class FragmentsOnCompositeTypesRuleTests: ValidationTestCase {
+    override func setUp() {
+        rule = FragmentsOnCompositeTypesRule
+    }
+
+    func testObjectIsValidFragmentType() throws {
+        try assertValid(
+            """
+            fragment validFragment on Dog {
+              barks
+            }
+            """
+        )
+    }
+
+    func testInterfaceIsValidFragmentType() throws {
+        try assertValid(
+            """
+            fragment validFragment on Pet {
+              name
+            }
+            """
+        )
+    }
+
+    func testObjectIsValidInlineFragmentType() throws {
+        try assertValid(
+            """
+            fragment validFragment on Pet {
+              ... on Dog {
+                barks
+              }
+            }
+            """
+        )
+    }
+
+    func testInterfaceIsValidInlineFragmentType() throws {
+        try assertValid(
+            """
+            fragment validFragment on Mammal {
+              ... on Canine {
+                name
+              }
+            }
+            """
+        )
+    }
+
+    func testInlineFragmentWithoutTypeIsValid() throws {
+        try assertValid(
+            """
+            fragment validFragment on Pet {
+              ... {
+                name
+              }
+            }
+            """
+        )
+    }
+
+    func testUnionIsValidFragmentType() throws {
+        try assertValid(
+            """
+            fragment validFragment on CatOrDog {
+              __typename
+            }
+            """
+        )
+    }
+
+    func testScalarIsInvalidFragmentType() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            fragment scalarFragment on Boolean {
+              bad
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 28)],
+            message: "Fragment \"scalarFragment\" cannot condition on non composite type \"Boolean\"."
+        )
+    }
+
+    func testEnumIsInvalidFragmentType() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            fragment scalarFragment on FurColor {
+              bad
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 28)],
+            message: "Fragment \"scalarFragment\" cannot condition on non composite type \"FurColor\"."
+        )
+    }
+
+    func testInputObjectIsInvalidFragmentType() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            fragment inputFragment on ComplexInput {
+              stringField
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 1, column: 27)],
+            message: "Fragment \"inputFragment\" cannot condition on non composite type \"ComplexInput\"."
+        )
+    }
+
+    func testScalarIsInvalidInlineFragmentType() throws {
+        let errors = try assertInvalid(
+            errorCount: 1,
+            query:
+            """
+            fragment invalidFragment on Pet {
+              ... on String {
+                barks
+              }
+            }
+            """
+        )
+        try assertValidationError(
+            error: errors[0],
+            locations: [(line: 2, column: 10)],
+            message: "Fragment cannot condition on non composite type \"String\"."
+        )
+    }
+}