feat: Adds LoneSchemaDefinitionRule

Author: NeedleInAJayStack

Sources/GraphQL/Validation/Rules/LoneSchemaDefinitionRule.swift

@@ -0,0 +1,42 @@
+
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+func LoneSchemaDefinitionRule(context: SDLValidationContext) -> Visitor {
+    let oldSchema = context.getSchema()
+    let alreadyDefined =
+        oldSchema?.astNode != nil ||
+        oldSchema?.queryType != nil ||
+        oldSchema?.mutationType != nil ||
+        oldSchema?.subscriptionType != nil
+
+    var schemaDefinitionsCount = 0
+    return Visitor(
+        enter: { node, _, _, _, _ in
+            if let node = node as? SchemaDefinition {
+                if alreadyDefined {
+                    context.report(
+                        error: GraphQLError(
+                            message: "Cannot define a new schema within a schema extension.",
+                            nodes: [node]
+                        )
+                    )
+                }
+
+                if schemaDefinitionsCount > 0 {
+                    context.report(
+                        error: GraphQLError(
+                            message: "Must provide only one schema definition.",
+                            nodes: [node]
+                        )
+                    )
+                }
+
+                schemaDefinitionsCount = schemaDefinitionsCount + 1
+            }
+            return .continue
+        }
+    )
+}

Sources/GraphQL/Validation/SpecifiedRules.swift

@@ -37,7 +37,7 @@ public let specifiedRules: [(ValidationContext) -> Visitor] = [
  * @internal
  */
 public let specifiedSDLRules: [SDLValidationRule] = [
-    //    LoneSchemaDefinitionRule,
+    LoneSchemaDefinitionRule,
 //    UniqueOperationTypesRule,
 //    UniqueTypeNamesRule,
 //    UniqueEnumValueNamesRule,

Tests/GraphQLTests/ValidationTests/LoneSchemaDefinitionRuleTests.swift

@@ -0,0 +1,160 @@
+@testable import GraphQL
+import XCTest
+
+class LoneSchemaDefinitionRuleTests: SDLValidationTestCase {
+    override func setUp() {
+        rule = LoneSchemaDefinitionRule
+    }
+
+    func testNoSchema() throws {
+        try assertValidationErrors(
+            """
+            type Query {
+              foo: String
+            }
+            """,
+            []
+        )
+    }
+
+    func testOneSchemaDefinition() throws {
+        try assertValidationErrors(
+            """
+            schema {
+              query: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+            """,
+            []
+        )
+    }
+
+    func testMultipleSchemaDefinitions() throws {
+        try assertValidationErrors(
+            """
+            schema {
+              query: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+
+            schema {
+              mutation: Foo
+            }
+
+            schema {
+              subscription: Foo
+            }
+            """,
+            [
+                GraphQLError(
+                    message: "Must provide only one schema definition.",
+                    locations: [.init(line: 9, column: 1)]
+                ),
+                GraphQLError(
+                    message: "Must provide only one schema definition.",
+                    locations: [.init(line: 13, column: 1)]
+                ),
+            ]
+        )
+    }
+
+    func testDefineSchemaInSchemaExtension() throws {
+        let schema = try buildSchema(source: """
+          type Foo {
+            foo: String
+          }
+        """)
+
+        try assertValidationErrors(
+            """
+              schema {
+                query: Foo
+              }
+            """,
+            schema: schema,
+            []
+        )
+    }
+
+    func testRedefineSchemaInSchemaExtension() throws {
+        let schema = try buildSchema(source: """
+        schema {
+          query: Foo
+        }
+
+        type Foo {
+          foo: String
+        }
+        """)
+
+        try assertValidationErrors(
+            """
+            schema {
+              mutation: Foo
+            }
+            """,
+            schema: schema,
+            [
+                GraphQLError(
+                    message: "Cannot define a new schema within a schema extension.",
+                    locations: [.init(line: 1, column: 1)]
+                ),
+            ]
+        )
+    }
+
+    func testRedefineImplicitSchemaInSchemaExtension() throws {
+        let schema = try buildSchema(source: """
+        type Query {
+          fooField: Foo
+        }
+
+        type Foo {
+          foo: String
+        }
+        """)
+
+        try assertValidationErrors(
+            """
+            schema {
+              mutation: Foo
+            }
+            """,
+            schema: schema,
+            [
+                GraphQLError(
+                    message: "Cannot define a new schema within a schema extension.",
+                    locations: [.init(line: 1, column: 1)]
+                ),
+            ]
+        )
+    }
+
+    func testExtendSchemaInSchemaExtension() throws {
+        let schema = try buildSchema(source: """
+        type Query {
+          fooField: Foo
+        }
+
+        type Foo {
+          foo: String
+        }
+        """)
+
+        try assertValidationErrors(
+            """
+            extend schema {
+              mutation: Foo
+            }
+            """,
+            schema: schema,
+            []
+        )
+    }
+}