add more extension definitions

Author: samisuteria

Sources/GraphQL/Language/AST.swift

@@ -1103,6 +1103,11 @@ extension SchemaDefinition: TypeSystemDefinition {}
 extension TypeExtensionDefinition: TypeSystemDefinition {}
 extension SchemaExtensionDefinition: TypeSystemDefinition {}
 extension DirectiveDefinition: TypeSystemDefinition {}
+extension InterfaceExtensionDefinition: TypeSystemDefinition {}
+extension ScalarExtensionDefinition: TypeSystemDefinition {}
+extension UnionExtensionDefinition: TypeSystemDefinition {}
+extension EnumExtensionDefinition: TypeSystemDefinition {}
+extension InputObjectExtensionDefinition: TypeSystemDefinition {}
 
 public func == (lhs: TypeSystemDefinition, rhs: TypeSystemDefinition) -> Bool {
     switch lhs {
@@ -1126,6 +1131,26 @@ public func == (lhs: TypeSystemDefinition, rhs: TypeSystemDefinition) -> Bool {
         if let r = rhs as? SchemaExtensionDefinition {
             return l == r
         }
+    case let l as InterfaceExtensionDefinition:
+        if let r = rhs as? InterfaceExtensionDefinition {
+            return l == r
+        }
+    case let l as ScalarExtensionDefinition:
+        if let r = rhs as? ScalarExtensionDefinition {
+            return l == r
+        }
+    case let l as UnionExtensionDefinition:
+        if let r = rhs as? UnionExtensionDefinition {
+            return l == r
+        }
+    case let l as EnumExtensionDefinition:
+        if let r = rhs as? EnumExtensionDefinition {
+            return l == r
+        }
+    case let l as InputObjectExtensionDefinition:
+        if let r = rhs as? InputObjectExtensionDefinition {
+            return l == r
+        }
     default:
         return false
     }
@@ -1567,6 +1592,91 @@ extension SchemaExtensionDefinition: Equatable {
     }
 }
 
+public final class InterfaceExtensionDefinition {
+    public let kind: Kind = .interfaceExtensionDefinition
+    public let loc: Location?
+    public let definition: InterfaceTypeDefinition
+
+    init(loc: Location? = nil, definition: InterfaceTypeDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension InterfaceExtensionDefinition: Equatable {
+    public static func == (lhs: InterfaceExtensionDefinition, rhs: InterfaceExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
+public final class ScalarExtensionDefinition {
+    public let kind: Kind = .scalarExtensionDefinition
+    public let loc: Location?
+    public let definition: ScalarTypeDefinition
+
+    init(loc: Location? = nil, definition: ScalarTypeDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension ScalarExtensionDefinition: Equatable {
+    public static func == (lhs: ScalarExtensionDefinition, rhs: ScalarExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
+public final class UnionExtensionDefinition {
+    public let kind: Kind = .unionExtensionDefinition
+    public let loc: Location?
+    public let definition: UnionTypeDefinition
+
+    init(loc: Location? = nil, definition: UnionTypeDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension UnionExtensionDefinition: Equatable {
+    public static func == (lhs: UnionExtensionDefinition, rhs: UnionExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
+public final class EnumExtensionDefinition {
+    public let kind: Kind = .enumExtensionDefinition
+    public let loc: Location?
+    public let definition: EnumTypeDefinition
+
+    init(loc: Location? = nil, definition: EnumTypeDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension EnumExtensionDefinition: Equatable {
+    public static func == (lhs: EnumExtensionDefinition, rhs: EnumExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
+public final class InputObjectExtensionDefinition {
+    public let kind: Kind = .inputObjectExtensionDefinition
+    public let loc: Location?
+    public let definition: InputObjectTypeDefinition
+
+    init(loc: Location? = nil, definition: InputObjectTypeDefinition) {
+        self.loc = loc
+        self.definition = definition
+    }
+}
+
+extension InputObjectExtensionDefinition: Equatable {
+    public static func == (lhs: InputObjectExtensionDefinition, rhs: InputObjectExtensionDefinition) -> Bool {
+        return lhs.definition == rhs.definition
+    }
+}
+
 public final class DirectiveDefinition {
     public let kind: Kind = .directiveDefinition
     public let loc: Location?

Sources/GraphQL/Language/Kinds.swift

@@ -37,4 +37,9 @@ public enum Kind {
     case typeExtensionDefinition
     case directiveDefinition
     case schemaExtensionDefinition
+    case interfaceExtensionDefinition
+    case scalarExtensionDefinition
+    case unionExtensionDefinition
+    case enumExtensionDefinition
+    case inputObjectExtensionDefinition
 }

Sources/GraphQL/Language/Parser.swift

@@ -1010,11 +1010,16 @@ func parseExtensionDefinition(lexer: Lexer) throws -> TypeSystemDefinition {
     switch token.value {
     case "type": return try parseTypeExtensionDefinition(lexer: lexer)
     case "schema": return try parseSchemaExtensionDefinition(lexer: lexer)
+    case "interface": return try parseInterfaceExtensionDefinition(lexer: lexer)
+    case "scalar": return try parseScalarExtensionDefinition(lexer: lexer)
+    case "union": return try parseUnionExtensionDefinition(lexer: lexer)
+    case "enum": return try parseEnumExtensionDefinition(lexer: lexer)
+    case "input": return try parseInputObjectExtensionDefinition(lexer: lexer)
     default:
         throw syntaxError(
             source: lexer.source,
             position: token.start,
-            description: "expected schema or type after extend"
+            description: "expected schema or type or interface or scalar or union or enum or input after extend"
         )
     }
 }
@@ -1052,6 +1057,71 @@ func parseSchemaExtensionDefinition(lexer: Lexer) throws -> SchemaExtensionDefin
     )
 }
 
+/**
+ * InterfaceExtensionDefinition: extend InterfaceTypeDefinition
+ */
+func parseInterfaceExtensionDefinition(lexer: Lexer) throws -> InterfaceExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let interfaceDefinition = try parseInterfaceTypeDefinition(lexer: lexer)
+    return InterfaceExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: interfaceDefinition
+    )
+}
+
+/**
+ * ScalarExtensionDefinition: extend InterfaceTypeDefinition
+ */
+func parseScalarExtensionDefinition(lexer: Lexer) throws -> ScalarExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let scalarDefinition = try parseScalarTypeDefinition(lexer: lexer)
+    return ScalarExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: scalarDefinition
+    )
+}
+
+/**
+ * UnionExtensionDefinition: extend UnionTypeDefinition
+ */
+func parseUnionExtensionDefinition(lexer: Lexer) throws -> UnionExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let definition = try parseUnionTypeDefinition(lexer: lexer)
+    return UnionExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: definition
+    )
+}
+
+/**
+ * EnumExtensionDefinition: extend EnumTypeDefinition
+ */
+func parseEnumExtensionDefinition(lexer: Lexer) throws -> EnumExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let definition = try parseEnumTypeDefinition(lexer: lexer)
+    return EnumExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: definition
+    )
+}
+
+/**
+ * InputObjectExtensionDefinition: extend InputObjectTypeDefinition
+ */
+func parseInputObjectExtensionDefinition(lexer: Lexer) throws -> InputObjectExtensionDefinition {
+    let start = lexer.token
+    try expectKeyword(lexer: lexer, value: "extend")
+    let definition = try parseInputObjectTypeDefinition(lexer: lexer)
+    return InputObjectExtensionDefinition(
+        loc: loc(lexer: lexer, startToken: start),
+        definition: definition
+    )
+}
+
 /**
  * DirectiveDefinition :
  *   - directive @ Name ArgumentsDefinition? on DirectiveLocations