Merge pull request #113 from samisuteria/extend-schema

Extend Schema Support

Author: NeedleInAJayStack

Sources/GraphQL/Language/AST.swift

@@ -213,6 +213,7 @@ extension EnumTypeDefinition: Node {}
 extension EnumValueDefinition: Node {}
 extension InputObjectTypeDefinition: Node {}
 extension TypeExtensionDefinition: Node {}
+extension SchemaExtensionDefinition: Node {}
 extension DirectiveDefinition: Node {}
 
 public final class Name {
@@ -1099,6 +1100,7 @@ extension NonNullType: Equatable {
 public protocol TypeSystemDefinition: Definition {}
 extension SchemaDefinition: TypeSystemDefinition {}
 extension TypeExtensionDefinition: TypeSystemDefinition {}
+extension SchemaExtensionDefinition: TypeSystemDefinition {}
 extension DirectiveDefinition: TypeSystemDefinition {}
 
 public func == (lhs: TypeSystemDefinition, rhs: TypeSystemDefinition) -> Bool {
@@ -1119,6 +1121,10 @@ public func == (lhs: TypeSystemDefinition, rhs: TypeSystemDefinition) -> Bool {
         if let r = rhs as? TypeDefinition {
             return l == r
         }
+    case let l as SchemaExtensionDefinition:
+        if let r = rhs as? SchemaExtensionDefinition {
+            return l == r
+        }
     default:
         return false
     }
@@ -1543,6 +1549,23 @@ extension TypeExtensionDefinition: Equatable {
     }
 }
 
+public final class SchemaExtensionDefinition {
+    public let kind: Kind = .schemaExtensionDefinition
+    public let loc: Location?
+    public let definition: SchemaDefinition
+
+    init(loc: Location? = nil, definition: SchemaDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension SchemaExtensionDefinition: Equatable {
+    public static func == (lhs: SchemaExtensionDefinition, rhs: SchemaExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
 public final class DirectiveDefinition {
     public let kind: Kind = .directiveDefinition
     public let loc: Location?

Sources/GraphQL/Language/Kinds.swift

@@ -36,4 +36,5 @@ public enum Kind {
     case inputObjectTypeDefinition
     case typeExtensionDefinition
     case directiveDefinition
+    case schemaExtensionDefinition
 }

Sources/GraphQL/Language/Parser.swift

@@ -706,7 +706,7 @@ func parseTypeSystemDefinition(lexer: Lexer) throws -> TypeSystemDefinition {
         case "union": return try parseUnionTypeDefinition(lexer: lexer)
         case "enum": return try parseEnumTypeDefinition(lexer: lexer)
         case "input": return try parseInputObjectTypeDefinition(lexer: lexer)
-        case "extend": return try parseTypeExtensionDefinition(lexer: lexer)
+        case "extend": return try parseExtensionDefinition(lexer: lexer)
         case "directive": return try parseDirectiveDefinition(lexer: lexer)
         default: break
         }
@@ -1002,6 +1002,16 @@ func parseInputObjectTypeDefinition(lexer: Lexer) throws -> InputObjectTypeDefin
     )
 }
 
+func parseExtensionDefinition(lexer: Lexer) throws -> TypeSystemDefinition {
+    let token = try lexer.lookahead()
+    switch token.value {
+    case "type": return try parseTypeExtensionDefinition(lexer: lexer)
+    case "schema": return try parseSchemaExtensionDefinition(lexer: lexer)
+    default:
+        throw syntaxError(source: lexer.source, position: token.start, description: "expected schema or type after extend")
+    }
+}
+
 /**
  * TypeExtensionDefinition : extend ObjectTypeDefinition
  */
@@ -1015,6 +1025,25 @@ func parseTypeExtensionDefinition(lexer: Lexer) throws -> TypeExtensionDefinitio
     )
 }
 
+/**
+ * SchemaExtensionDefinition: extend SchemaExtensionDefinition
+ */
+func parseSchemaExtensionDefinition(lexer: Lexer) throws -> SchemaExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let description = try parseDescription(lexer: lexer)
+    try expectKeyword(lexer: lexer, value: "schema")
+    let directives = try parseDirectives(lexer: lexer)
+    return SchemaExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: SchemaDefinition(
+            loc: loc(lexer: lexer, startToken: start),
+            description: description,
+            directives: directives,
+            operationTypes: []
+    ))
+}
+
 /**
  * DirectiveDefinition :
  *   - directive @ Name ArgumentsDefinition? on DirectiveLocations

Tests/GraphQLTests/LanguageTests/SchemaParserTests.swift

@@ -111,6 +111,64 @@ class SchemaParserTests: XCTestCase {
         XCTAssert(result == expected)
     }
 
+    func testSchemeExtension() throws {
+        // Based on Apollo Federation example schema: https://github.com/apollographql/apollo-federation-subgraph-compatibility/blob/main/COMPATIBILITY.md#products-schema-to-be-implemented-by-library-maintainers
+        let source =
+            """
+            extend schema
+              @link(
+                url: "https://specs.apollo.dev/federation/v2.0",
+                import: [
+                  "@extends",
+                  "@external",
+                  "@key",
+                  "@inaccessible",
+                  "@override",
+                  "@provides",
+                  "@requires",
+                  "@shareable",
+                  "@tag"
+                ]
+              )
+            """
+
+        let expected = Document(
+            definitions: [
+                SchemaExtensionDefinition(
+                    definition: SchemaDefinition(
+                        directives: [
+                            Directive(
+                                name: nameNode("link"),
+                                arguments: [
+                                    Argument(
+                                        name: nameNode("url"),
+                                        value: StringValue(
+                                            value: "https://specs.apollo.dev/federation/v2.0",
+                                            block: false
+                                        )
+                                    ),
+                                    Argument(
+                                        name: nameNode("import"),
+                                        value: ListValue(values: [
+                                            StringValue(value: "@extends", block: false),
+                                            StringValue(value: "@external", block: false),
+                                            StringValue(value: "@key", block: false),
+                                            StringValue(value: "@inaccessible", block: false),
+                                            StringValue(value: "@override", block: false),
+                                            StringValue(value: "@provides", block: false),
+                                            StringValue(value: "@requires", block: false),
+                                            StringValue(value: "@shareable", block: false),
+                                            StringValue(value: "@tag", block: false),
+                                        ]))
+                                ])
+                        ],
+                        operationTypes: []))
+            ])
+
+        let result = try parse(source: source)
+        XCTAssert(result == expected)
+    }
+
     func testSimpleNonNullType() throws {
         let source = "type Hello { world: String! }"