diff --git a/src/Language/AST/DocumentNode.php b/src/Language/AST/DocumentNode.php
index 3b41868..bcf051b 100644
--- a/src/Language/AST/DocumentNode.php
+++ b/src/Language/AST/DocumentNode.php
@@ -9,6 +9,6 @@ class DocumentNode extends Node
     /** @var string */
     public $kind = NodeKind::DOCUMENT;
 
-    /** @var DefinitionNode[] */
+    /** @var NodeList|DefinitionNode[] */
     public $definitions;
 }
diff --git a/src/Type/Definition/Type.php b/src/Type/Definition/Type.php
index b89bbf4..f9c12ad 100644
--- a/src/Type/Definition/Type.php
+++ b/src/Type/Definition/Type.php
@@ -7,6 +7,7 @@ namespace GraphQL\Type\Definition;
 use Exception;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Language\AST\TypeDefinitionNode;
+use GraphQL\Language\AST\TypeExtensionNode;
 use GraphQL\Type\Introspection;
 use GraphQL\Utils\Utils;
 use JsonSerializable;
@@ -47,6 +48,9 @@ abstract class Type implements JsonSerializable
     /** @var mixed[] */
     public $config;
 
+    /** @var TypeExtensionNode[] */
+    public $extensionASTNodes;
+
     /**
      * @return IDType
      *
diff --git a/src/Utils/ASTDefinitionBuilder.php b/src/Utils/ASTDefinitionBuilder.php
index 50a8e47..6e985a3 100644
--- a/src/Utils/ASTDefinitionBuilder.php
+++ b/src/Utils/ASTDefinitionBuilder.php
@@ -12,6 +12,7 @@ use GraphQL\Language\AST\EnumTypeExtensionNode;
 use GraphQL\Language\AST\EnumValueDefinitionNode;
 use GraphQL\Language\AST\FieldDefinitionNode;
 use GraphQL\Language\AST\InputObjectTypeDefinitionNode;
+use GraphQL\Language\AST\InputValueDefinitionNode;
 use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
 use GraphQL\Language\AST\ListTypeNode;
 use GraphQL\Language\AST\NamedTypeNode;
@@ -492,4 +493,37 @@ class ASTDefinitionBuilder
 
         return $innerType;
     }
+
+    /**
+     * @return mixed[]
+     */
+    public function buildInputField(InputValueDefinitionNode $value) : array
+    {
+        $type = $this->internalBuildWrappedType($value->type);
+
+        $config = [
+            'name' => $value->name->value,
+            'type' => $type,
+            'description' => $this->getDescription($value),
+            'astNode' => $value,
+        ];
+
+        if ($value->defaultValue) {
+            $config['defaultValue'] = $value->defaultValue;
+        }
+
+        return $config;
+    }
+
+    /**
+     * @return mixed[]
+     */
+    public function buildEnumValue(EnumValueDefinitionNode $value) : array
+    {
+        return [
+            'description' => $this->getDescription($value),
+            'deprecationReason' => $this->getDeprecationReason($value),
+            'astNode' => $value,
+        ];
+    }
 }
diff --git a/src/Utils/SchemaExtender.php b/src/Utils/SchemaExtender.php
new file mode 100644
index 0000000..1812b7d
--- /dev/null
+++ b/src/Utils/SchemaExtender.php
@@ -0,0 +1,622 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Utils;
+
+use GraphQL\Error\Error;
+use GraphQL\Language\AST\DirectiveDefinitionNode;
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\NodeKind;
+use GraphQL\Language\AST\ObjectTypeExtensionNode;
+use GraphQL\Language\AST\SchemaDefinitionNode;
+use GraphQL\Language\AST\SchemaTypeExtensionNode;
+use GraphQL\Language\AST\TypeDefinitionNode;
+use GraphQL\Language\AST\TypeExtensionNode;
+use GraphQL\Type\Definition\CustomScalarType;
+use GraphQL\Type\Definition\Directive;
+use GraphQL\Type\Definition\EnumType;
+use GraphQL\Type\Definition\EnumValueDefinition;
+use GraphQL\Type\Definition\FieldArgument;
+use GraphQL\Type\Definition\InputObjectType;
+use GraphQL\Type\Definition\InterfaceType;
+use GraphQL\Type\Definition\ListOfType;
+use GraphQL\Type\Definition\NamedType;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\UnionType;
+use GraphQL\Type\Introspection;
+use GraphQL\Type\Schema;
+use GraphQL\Validator\DocumentValidator;
+use function array_keys;
+use function array_map;
+use function array_merge;
+use function array_values;
+use function count;
+
+class SchemaExtender
+{
+    const SCHEMA_EXTENSION = 'SchemaExtension';
+
+    /** @var Type[] */
+    protected static $extendTypeCache;
+
+    /** @var mixed[] */
+    protected static $typeExtensionsMap;
+
+    /** @var ASTDefinitionBuilder */
+    protected static $astBuilder;
+
+    /**
+     * @return TypeExtensionNode[]|null
+     */
+    protected static function getExtensionASTNodes(NamedType $type) : ?array
+    {
+        if (! $type instanceof Type) {
+            return null;
+        }
+
+        $name = $type->name;
+        if ($type->extensionASTNodes !== null) {
+            if (isset(static::$typeExtensionsMap[$name])) {
+                return array_merge($type->extensionASTNodes, static::$typeExtensionsMap[$name]);
+            }
+
+            return $type->extensionASTNodes;
+        }
+        return static::$typeExtensionsMap[$name] ?? null;
+    }
+
+    /**
+     * @throws Error
+     */
+    protected static function checkExtensionNode(Type $type, Node $node) : void
+    {
+        switch ($node->kind ?? null) {
+            case NodeKind::OBJECT_TYPE_EXTENSION:
+                if (! ($type instanceof ObjectType)) {
+                    throw new Error(
+                        'Cannot extend non-object type "' . $type->name . '".',
+                        [$node]
+                    );
+                }
+                break;
+            case NodeKind::INTERFACE_TYPE_EXTENSION:
+                if (! ($type instanceof InterfaceType)) {
+                    throw new Error(
+                        'Cannot extend non-interface type "' . $type->name . '".',
+                        [$node]
+                    );
+                }
+                break;
+            case NodeKind::ENUM_TYPE_EXTENSION:
+                if (! ($type instanceof EnumType)) {
+                    throw new Error(
+                        'Cannot extend non-enum type "' . $type->name . '".',
+                        [$node]
+                    );
+                }
+                break;
+            case NodeKind::UNION_TYPE_EXTENSION:
+                if (! ($type instanceof UnionType)) {
+                    throw new Error(
+                        'Cannot extend non-union type "' . $type->name . '".',
+                        [$node]
+                    );
+                }
+                break;
+            case NodeKind::INPUT_OBJECT_TYPE_EXTENSION:
+                if (! ($type instanceof InputObjectType)) {
+                    throw new Error(
+                        'Cannot extend non-input object type "' . $type->name . '".',
+                        [$node]
+                    );
+                }
+                break;
+        }
+    }
+
+    protected static function extendCustomScalarType(CustomScalarType $type) : CustomScalarType
+    {
+        return new CustomScalarType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'astNode' => $type->astNode,
+            'serialize' => $type->config['serialize'] ?? null,
+            'parseValue' => $type->config['parseValue'] ?? null,
+            'parseLiteral' => $type->config['parseLiteral'] ?? null,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+        ]);
+    }
+
+    protected static function extendUnionType(UnionType $type) : UnionType
+    {
+        return new UnionType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'types' => static function () use ($type) {
+                return static::extendPossibleTypes($type);
+            },
+            'astNode' => $type->astNode,
+            'resolveType' => $type->config['resolveType'] ?? null,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+        ]);
+    }
+
+    protected static function extendEnumType(EnumType $type) : EnumType
+    {
+        return new EnumType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'values' => static::extendValueMap($type),
+            'astNode' => $type->astNode,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+        ]);
+    }
+
+    protected static function extendInputObjectType(InputObjectType $type) : InputObjectType
+    {
+        return new InputObjectType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'fields' => static function () use ($type) {
+                return static::extendInputFieldMap($type);
+            },
+            'astNode' => $type->astNode,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+        ]);
+    }
+
+    /**
+     * @return mixed[]
+     */
+    protected static function extendInputFieldMap(InputObjectType $type) : array
+    {
+        $newFieldMap = [];
+        $oldFieldMap = $type->getFields();
+        foreach ($oldFieldMap as $fieldName => $field) {
+            $newFieldMap[$fieldName] = [
+                'description' => $field->description,
+                'type' => static::extendType($field->type),
+                'astNode' => $field->astNode,
+            ];
+
+            if (! $field->defaultValueExists()) {
+                continue;
+            }
+
+            $newFieldMap[$fieldName]['defaultValue'] = $field->defaultValue;
+        }
+
+        $extensions = static::$typeExtensionsMap[$type->name] ?? null;
+        if ($extensions !== null) {
+            foreach ($extensions as $extension) {
+                foreach ($extension->fields as $field) {
+                    $fieldName = $field->name->value;
+                    if (isset($oldFieldMap[$fieldName])) {
+                        throw new Error('Field "' . $type->name . '.' . $fieldName . '" already exists in the schema. It cannot also be defined in this type extension.', [$field]);
+                    }
+
+                    $newFieldMap[$fieldName] = static::$astBuilder->buildInputField($field);
+                }
+            }
+        }
+
+        return $newFieldMap;
+    }
+
+    /**
+     * @return mixed[]
+     */
+    protected static function extendValueMap(EnumType $type) : array
+    {
+        $newValueMap = [];
+        /** @var EnumValueDefinition[] $oldValueMap */
+        $oldValueMap = [];
+        foreach ($type->getValues() as $value) {
+            $oldValueMap[$value->name] = $value;
+        }
+
+        foreach ($oldValueMap as $key => $value) {
+            $newValueMap[$key] = [
+                'name' => $value->name,
+                'description' => $value->description,
+                'value' => $value->value,
+                'deprecationReason' => $value->deprecationReason,
+                'astNode' => $value->astNode,
+            ];
+        }
+
+        $extensions = static::$typeExtensionsMap[$type->name] ?? null;
+        if ($extensions !== null) {
+            foreach ($extensions as $extension) {
+                foreach ($extension->values as $value) {
+                    $valueName = $value->name->value;
+                    if (isset($oldValueMap[$valueName])) {
+                        throw new Error('Enum value "' . $type->name . '.' . $valueName . '" already exists in the schema. It cannot also be defined in this type extension.', [$value]);
+                    }
+                    $newValueMap[$valueName] = static::$astBuilder->buildEnumValue($value);
+                }
+            }
+        }
+
+        return $newValueMap;
+    }
+
+    /**
+     * @return ObjectType[]
+     */
+    protected static function extendPossibleTypes(UnionType $type) : array
+    {
+        $possibleTypes = array_map(static function ($type) {
+            return static::extendNamedType($type);
+        }, $type->getTypes());
+
+        $extensions = static::$typeExtensionsMap[$type->name] ?? null;
+        if ($extensions !== null) {
+            foreach ($extensions as $extension) {
+                foreach ($extension->types as $namedType) {
+                    $possibleTypes[] = static::$astBuilder->buildType($namedType);
+                }
+            }
+        }
+
+        return $possibleTypes;
+    }
+
+    /**
+     * @return InterfaceType[]
+     */
+    protected static function extendImplementedInterfaces(ObjectType $type) : array
+    {
+        $interfaces = array_map(static function (InterfaceType $interfaceType) {
+            return static::extendNamedType($interfaceType);
+        }, $type->getInterfaces());
+
+        $extensions = static::$typeExtensionsMap[$type->name] ?? null;
+        if ($extensions !== null) {
+            /** @var ObjectTypeExtensionNode $extension */
+            foreach ($extensions as $extension) {
+                foreach ($extension->interfaces as $namedType) {
+                    $interfaces[] = static::$astBuilder->buildType($namedType);
+                }
+            }
+        }
+        return $interfaces;
+    }
+
+    protected static function extendType($typeDef)
+    {
+        if ($typeDef instanceof ListOfType) {
+            return Type::listOf(static::extendType($typeDef->ofType));
+        }
+
+        if ($typeDef instanceof NonNull) {
+            return Type::nonNull(static::extendType($typeDef->getWrappedType()));
+        }
+
+        return static::extendNamedType($typeDef);
+    }
+
+    /**
+     * @param FieldArgument[] $args
+     *
+     * @return mixed[]
+     */
+    protected static function extendArgs(array $args) : array
+    {
+        return Utils::keyValMap(
+            $args,
+            static function (FieldArgument $arg) {
+                return $arg->name;
+            },
+            static function (FieldArgument $arg) {
+                $def = [
+                    'type'        => static::extendType($arg->getType()),
+                    'description' => $arg->description,
+                    'astNode'     => $arg->astNode,
+                ];
+
+                if ($arg->defaultValueExists()) {
+                    $def['defaultValue'] = $arg->defaultValue;
+                }
+
+                return $def;
+            }
+        );
+    }
+
+    /**
+     * @param InterfaceType|ObjectType $type
+     *
+     * @return mixed[]
+     *
+     * @throws Error
+     */
+    protected static function extendFieldMap($type) : array
+    {
+        $newFieldMap = [];
+        $oldFieldMap = $type->getFields();
+
+        foreach (array_keys($oldFieldMap) as $fieldName) {
+            $field = $oldFieldMap[$fieldName];
+
+            $newFieldMap[$fieldName] = [
+                'name' => $fieldName,
+                'description' => $field->description,
+                'deprecationReason' => $field->deprecationReason,
+                'type' => static::extendType($field->getType()),
+                'args' => static::extendArgs($field->args),
+                'astNode' => $field->astNode,
+                'resolveFn' => $field->resolveFn,
+            ];
+        }
+
+        $extensions = static::$typeExtensionsMap[$type->name] ?? null;
+        if ($extensions !== null) {
+            foreach ($extensions as $extension) {
+                foreach ($extension->fields as $field) {
+                    $fieldName = $field->name->value;
+                    if (isset($oldFieldMap[$fieldName])) {
+                        throw new Error('Field "' . $type->name . '.' . $fieldName . '" already exists in the schema. It cannot also be defined in this type extension.', [$field]);
+                    }
+
+                    $newFieldMap[$fieldName] = static::$astBuilder->buildField($field);
+                }
+            }
+        }
+
+        return $newFieldMap;
+    }
+
+    protected static function extendObjectType(ObjectType $type) : ObjectType
+    {
+        return new ObjectType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'interfaces' => static function () use ($type) {
+                return static::extendImplementedInterfaces($type);
+            },
+            'fields' => static function () use ($type) {
+                return static::extendFieldMap($type);
+            },
+            'astNode' => $type->astNode,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+            'isTypeOf' => $type->config['isTypeOf'] ?? null,
+        ]);
+    }
+
+    protected static function extendInterfaceType(InterfaceType $type) : InterfaceType
+    {
+        return new InterfaceType([
+            'name' => $type->name,
+            'description' => $type->description,
+            'fields' => static function () use ($type) {
+                return static::extendFieldMap($type);
+            },
+            'astNode' => $type->astNode,
+            'extensionASTNodes' => static::getExtensionASTNodes($type),
+            'resolveType' => $type->config['resolveType'] ?? null,
+        ]);
+    }
+
+    protected static function isSpecifiedScalarType(Type $type) : bool
+    {
+        return $type instanceof NamedType &&
+            (
+                $type->name === Type::STRING ||
+                $type->name === Type::INT ||
+                $type->name === Type::FLOAT ||
+                $type->name === Type::BOOLEAN ||
+                $type->name === Type::ID
+            );
+    }
+
+    protected static function extendNamedType(Type $type)
+    {
+        if (Introspection::isIntrospectionType($type) || static::isSpecifiedScalarType($type)) {
+            return $type;
+        }
+
+        $name = $type->name;
+        if (! isset(static::$extendTypeCache[$name])) {
+            if ($type instanceof CustomScalarType) {
+                static::$extendTypeCache[$name] = static::extendCustomScalarType($type);
+            } elseif ($type instanceof ObjectType) {
+                static::$extendTypeCache[$name] = static::extendObjectType($type);
+            } elseif ($type instanceof InterfaceType) {
+                static::$extendTypeCache[$name] = static::extendInterfaceType($type);
+            } elseif ($type instanceof UnionType) {
+                static::$extendTypeCache[$name] = static::extendUnionType($type);
+            } elseif ($type instanceof EnumType) {
+                static::$extendTypeCache[$name] = static::extendEnumType($type);
+            } elseif ($type instanceof InputObjectType) {
+                static::$extendTypeCache[$name] = static::extendInputObjectType($type);
+            }
+        }
+
+        return static::$extendTypeCache[$name];
+    }
+
+    /**
+     * @return mixed|null
+     */
+    protected static function extendMaybeNamedType(?NamedType $type = null)
+    {
+        if ($type !== null) {
+            return static::extendNamedType($type);
+        }
+
+        return null;
+    }
+
+    /**
+     * @param DirectiveDefinitionNode[] $directiveDefinitions
+     *
+     * @return Directive[]
+     */
+    protected static function getMergedDirectives(Schema $schema, array $directiveDefinitions) : array
+    {
+        $existingDirectives = array_map(static function (Directive $directive) {
+            return static::extendDirective($directive);
+        }, $schema->getDirectives());
+
+        Utils::invariant(count($existingDirectives) > 0, 'schema must have default directives');
+
+        return array_merge(
+            $existingDirectives,
+            array_map(static function (DirectiveDefinitionNode $directive) {
+                return static::$astBuilder->buildDirective($directive);
+            }, $directiveDefinitions)
+        );
+    }
+
+    protected static function extendDirective(Directive $directive) : Directive
+    {
+        return new Directive([
+            'name' => $directive->name,
+            'description' => $directive->description,
+            'locations' => $directive->locations,
+            'args' => static::extendArgs($directive->args),
+            'astNode' => $directive->astNode,
+        ]);
+    }
+
+    /**
+     * @param mixed[]|null $options
+     */
+    public static function extend(Schema $schema, DocumentNode $documentAST, ?array $options = null) : Schema
+    {
+        if ($options === null || ! (isset($options['assumeValid']) || isset($options['assumeValidSDL']))) {
+            DocumentValidator::assertValidSDLExtension($documentAST, $schema);
+        }
+
+        $typeDefinitionMap         = [];
+        static::$typeExtensionsMap = [];
+        $directiveDefinitions      = [];
+        /** @var SchemaDefinitionNode|null $schemaDef */
+        $schemaDef = null;
+        /** @var SchemaTypeExtensionNode[] $schemaExtensions */
+        $schemaExtensions = [];
+
+        $definitionsCount = count($documentAST->definitions);
+        for ($i = 0; $i < $definitionsCount; $i++) {
+
+            /** @var Node $def */
+            $def = $documentAST->definitions[$i];
+
+            if ($def instanceof SchemaDefinitionNode) {
+                $schemaDef = $def;
+            } elseif ($def instanceof SchemaTypeExtensionNode) {
+                $schemaExtensions[] = $def;
+            } elseif ($def instanceof TypeDefinitionNode) {
+                $typeName = isset($def->name) ? $def->name->value : null;
+                if ($schema->getType($typeName)) {
+                    throw new Error('Type "' . $typeName . '" already exists in the schema. It cannot also be defined in this type definition.', [$def]);
+                }
+                $typeDefinitionMap[$typeName] = $def;
+            } elseif ($def instanceof TypeExtensionNode) {
+                $extendedTypeName = isset($def->name) ? $def->name->value : null;
+                $existingType     = $schema->getType($extendedTypeName);
+                if ($existingType === null) {
+                    throw new Error('Cannot extend type "' . $extendedTypeName . '" because it does not exist in the existing schema.', [$def]);
+                }
+
+                static::checkExtensionNode($existingType, $def);
+
+                $existingTypeExtensions                       = static::$typeExtensionsMap[$extendedTypeName] ?? null;
+                static::$typeExtensionsMap[$extendedTypeName] = $existingTypeExtensions !== null ? array_merge($existingTypeExtensions, [$def]) : [$def];
+            } elseif ($def instanceof DirectiveDefinitionNode) {
+                $directiveName     = $def->name->value;
+                $existingDirective = $schema->getDirective($directiveName);
+                if ($existingDirective !== null) {
+                    throw new Error('Directive "' . $directiveName . '" already exists in the schema. It cannot be redefined.', [$def]);
+                }
+                $directiveDefinitions[] = $def;
+            }
+        }
+
+        if (count(static::$typeExtensionsMap) === 0 &&
+            count($typeDefinitionMap) === 0 &&
+            count($directiveDefinitions) === 0 &&
+            count($schemaExtensions) === 0 &&
+            $schemaDef === null
+        ) {
+            return $schema;
+        }
+
+        static::$astBuilder = new ASTDefinitionBuilder(
+            $typeDefinitionMap,
+            $options,
+            static function (string $typeName) use ($schema) {
+                /** @var NamedType $existingType */
+                $existingType = $schema->getType($typeName);
+                if ($existingType !== null) {
+                    return static::extendNamedType($existingType);
+                }
+
+                throw new Error('Unknown type: "' . $typeName . '". Ensure that this type exists either in the original schema, or is added in a type definition.', [$typeName]);
+            }
+        );
+
+        static::$extendTypeCache = [];
+
+        $operationTypes = [
+            'query' => static::extendMaybeNamedType($schema->getQueryType()),
+            'mutation' => static::extendMaybeNamedType($schema->getMutationType()),
+            'subscription' => static::extendMaybeNamedType($schema->getSubscriptionType()),
+        ];
+
+        if ($schemaDef) {
+            foreach ($schemaDef->operationTypes as $operationType) {
+                $operation = $operationType->operation;
+                $type      = $operationType->type;
+
+                if (isset($operationTypes[$operation])) {
+                    throw new Error('Must provide only one ' . $operation . ' type in schema.');
+                }
+
+                $operationTypes[$operation] = static::$astBuilder->buildType($type);
+            }
+        }
+
+        foreach ($schemaExtensions as $schemaExtension) {
+            if (! $schemaExtension->operationTypes) {
+                continue;
+            }
+
+            foreach ($schemaExtension->operationTypes as $operationType) {
+                $operation = $operationType->operation;
+                if ($operationTypes[$operation]) {
+                    throw new Error('Must provide only one ' . $operation . ' type in schema.');
+                }
+                $operationTypes[$operation] = static::$astBuilder->buildType($operationType->type);
+            }
+        }
+
+        $schemaExtensionASTNodes = count($schemaExtensions) > 0
+            ? ($schema->extensionASTNodes ? array_merge($schema->extensionASTNodes, $schemaExtensions) : $schemaExtensions)
+            : $schema->extensionASTNodes;
+
+        $types = array_merge(
+            array_map(static function ($type) {
+                return static::extendType($type);
+            }, array_values($schema->getTypeMap())),
+            array_map(static function ($type) {
+                return static::$astBuilder->buildType($type);
+            }, array_values($typeDefinitionMap))
+        );
+
+        return new Schema([
+            'query' => $operationTypes['query'],
+            'mutation' => $operationTypes['mutation'],
+            'subscription' => $operationTypes['subscription'],
+            'types' => $types,
+            'directives' => static::getMergedDirectives($schema, $directiveDefinitions),
+            'astNode' => $schema->getAstNode(),
+            'extensionASTNodes' => $schemaExtensionASTNodes,
+        ]);
+    }
+}
diff --git a/src/Validator/DocumentValidator.php b/src/Validator/DocumentValidator.php
index a3cde92..6a1ba94 100644
--- a/src/Validator/DocumentValidator.php
+++ b/src/Validator/DocumentValidator.php
@@ -16,10 +16,12 @@ use GraphQL\Validator\Rules\ExecutableDefinitions;
 use GraphQL\Validator\Rules\FieldsOnCorrectType;
 use GraphQL\Validator\Rules\FragmentsOnCompositeTypes;
 use GraphQL\Validator\Rules\KnownArgumentNames;
+use GraphQL\Validator\Rules\KnownArgumentNamesOnDirectives;
 use GraphQL\Validator\Rules\KnownDirectives;
 use GraphQL\Validator\Rules\KnownFragmentNames;
 use GraphQL\Validator\Rules\KnownTypeNames;
 use GraphQL\Validator\Rules\LoneAnonymousOperation;
+use GraphQL\Validator\Rules\LoneSchemaDefinition;
 use GraphQL\Validator\Rules\NoFragmentCycles;
 use GraphQL\Validator\Rules\NoUndefinedVariables;
 use GraphQL\Validator\Rules\NoUnusedFragments;
@@ -27,6 +29,7 @@ use GraphQL\Validator\Rules\NoUnusedVariables;
 use GraphQL\Validator\Rules\OverlappingFieldsCanBeMerged;
 use GraphQL\Validator\Rules\PossibleFragmentSpreads;
 use GraphQL\Validator\Rules\ProvidedNonNullArguments;
+use GraphQL\Validator\Rules\ProvidedRequiredArgumentsOnDirectives;
 use GraphQL\Validator\Rules\QueryComplexity;
 use GraphQL\Validator\Rules\QueryDepth;
 use GraphQL\Validator\Rules\QuerySecurityRule;
@@ -44,10 +47,13 @@ use GraphQL\Validator\Rules\VariablesDefaultValueAllowed;
 use GraphQL\Validator\Rules\VariablesInAllowedPosition;
 use Throwable;
 use function array_filter;
+use function array_map;
 use function array_merge;
 use function count;
+use function implode;
 use function is_array;
 use function sprintf;
+use const PHP_EOL;
 
 /**
  * Implements the "Validation" section of the spec.
@@ -78,6 +84,9 @@ class DocumentValidator
     /** @var QuerySecurityRule[]|null */
     private static $securityRules;
 
+    /** @var ValidationRule[]|null */
+    private static $sdlRules;
+
     /** @var bool */
     private static $initRules = false;
 
@@ -183,6 +192,23 @@ class DocumentValidator
         return self::$securityRules;
     }
 
+    public static function sdlRules()
+    {
+        if (self::$sdlRules === null) {
+            self::$sdlRules = [
+                LoneSchemaDefinition::class                  => new LoneSchemaDefinition(),
+                KnownDirectives::class                       => new KnownDirectives(),
+                KnownArgumentNamesOnDirectives::class        => new KnownArgumentNamesOnDirectives(),
+                UniqueDirectivesPerLocation::class           => new UniqueDirectivesPerLocation(),
+                UniqueArgumentNames::class                   => new UniqueArgumentNames(),
+                UniqueInputFieldNames::class                 => new UniqueInputFieldNames(),
+                ProvidedRequiredArgumentsOnDirectives::class => new ProvidedRequiredArgumentsOnDirectives(),
+            ];
+        }
+
+        return self::$sdlRules;
+    }
+
     /**
      * This uses a specialized visitor which runs multiple visitors in parallel,
      * while maintaining the visitor skip and break API.
@@ -264,7 +290,8 @@ class DocumentValidator
     /**
      * Utility which determines if a value literal node is valid for an input type.
      *
-     * Deprecated. Rely on validation for documents containing literal values.
+     * Deprecated. Rely on validation for documents co
+     * ntaining literal values.
      *
      * @deprecated
      *
@@ -282,4 +309,19 @@ class DocumentValidator
 
         return $context->getErrors();
     }
+
+    public static function assertValidSDLExtension(DocumentNode $documentAST, Schema $schema)
+    {
+        $errors = self::visitUsingRules($schema, new TypeInfo($schema), $documentAST, self::sdlRules());
+        if (count($errors) !== 0) {
+            throw new Error(
+                implode(
+                    PHP_EOL . PHP_EOL,
+                    array_map(static function (Error $error) : string {
+                        return $error->message;
+                    }, $errors)
+                )
+            );
+        }
+    }
 }
diff --git a/src/Validator/Rules/KnownArgumentNamesOnDirectives.php b/src/Validator/Rules/KnownArgumentNamesOnDirectives.php
new file mode 100644
index 0000000..7ffd986
--- /dev/null
+++ b/src/Validator/Rules/KnownArgumentNamesOnDirectives.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Validator\Rules;
+
+use GraphQL\Error\Error;
+use GraphQL\Language\AST\DirectiveDefinitionNode;
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\InputValueDefinitionNode;
+use GraphQL\Language\AST\NodeKind;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Type\Definition\Directive;
+use GraphQL\Type\Definition\FieldArgument;
+use GraphQL\Validator\ValidationContext;
+use function array_map;
+use function in_array;
+use function iterator_to_array;
+
+/**
+ * Known argument names on directives
+ *
+ * A GraphQL directive is only valid if all supplied arguments are defined by
+ * that field.
+ */
+class KnownArgumentNamesOnDirectives extends ValidationRule
+{
+    protected static function unknownDirectiveArgMessage(string $argName, string $directionName)
+    {
+        return 'Unknown argument "' . $argName . '" on directive "@' . $directionName . '".';
+    }
+
+    public function getVisitor(ValidationContext $context)
+    {
+        $directiveArgs     = [];
+        $schema            = $context->getSchema();
+        $definedDirectives = $schema !== null ? $schema->getDirectives() : Directive::getInternalDirectives();
+
+        foreach ($definedDirectives as $directive) {
+            $directiveArgs[$directive->name] = array_map(
+                static function (FieldArgument $arg) : string {
+                    return $arg->name;
+                },
+                $directive->args
+            );
+        }
+
+        $astDefinitions = $context->getDocument()->definitions;
+        foreach ($astDefinitions as $def) {
+            if (! ($def instanceof DirectiveDefinitionNode)) {
+                continue;
+            }
+
+            $name = $def->name->value;
+            if ($def->arguments !== null) {
+                $arguments = $def->arguments;
+
+                if ($arguments instanceof NodeList) {
+                    $arguments = iterator_to_array($arguments->getIterator());
+                }
+
+                $directiveArgs[$name] = array_map(static function (InputValueDefinitionNode $arg) : string {
+                    return $arg->name->value;
+                }, $arguments);
+            } else {
+                $directiveArgs[$name] = [];
+            }
+        }
+
+        return [
+            NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($directiveArgs, $context) {
+                $directiveName = $directiveNode->name->value;
+                $knownArgs     = $directiveArgs[$directiveName] ?? null;
+
+                if ($directiveNode->arguments === null || ! $knownArgs) {
+                    return;
+                }
+
+                foreach ($directiveNode->arguments as $argNode) {
+                    $argName = $argNode->name->value;
+                    if (in_array($argName, $knownArgs)) {
+                        continue;
+                    }
+
+                    $context->reportError(new Error(
+                        self::unknownDirectiveArgMessage($argName, $directiveName),
+                        [$argNode]
+                    ));
+                }
+            },
+        ];
+    }
+}
diff --git a/src/Validator/Rules/LoneSchemaDefinition.php b/src/Validator/Rules/LoneSchemaDefinition.php
new file mode 100644
index 0000000..4cef206
--- /dev/null
+++ b/src/Validator/Rules/LoneSchemaDefinition.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Validator\Rules;
+
+use GraphQL\Error\Error;
+use GraphQL\Language\AST\NodeKind;
+use GraphQL\Language\AST\SchemaDefinitionNode;
+use GraphQL\Validator\ValidationContext;
+
+/**
+ * Lone Schema definition
+ *
+ * A GraphQL document is only valid if it contains only one schema definition.
+ */
+class LoneSchemaDefinition extends ValidationRule
+{
+    public function getVisitor(ValidationContext $context)
+    {
+        $oldSchema      = $context->getSchema();
+        $alreadyDefined = $oldSchema !== null ? (
+            $oldSchema->getAstNode() ||
+            $oldSchema->getQueryType() ||
+            $oldSchema->getMutationType() ||
+            $oldSchema->getSubscriptionType()
+        ) : false;
+
+        $schemaDefinitionsCount = 0;
+
+        return [
+            NodeKind::SCHEMA_DEFINITION => static function (SchemaDefinitionNode $node) use ($alreadyDefined, $context, &$schemaDefinitionsCount) {
+                if ($alreadyDefined !== false) {
+                    $context->reportError(new Error('Cannot define a new schema within a schema extension.', $node));
+                    return;
+                }
+
+                if ($schemaDefinitionsCount > 0) {
+                    $context->reportError(new Error('Must provide only one schema definition.', $node));
+                }
+
+                ++$schemaDefinitionsCount;
+            },
+        ];
+    }
+}
diff --git a/src/Validator/Rules/ProvidedRequiredArgumentsOnDirectives.php b/src/Validator/Rules/ProvidedRequiredArgumentsOnDirectives.php
new file mode 100644
index 0000000..8750711
--- /dev/null
+++ b/src/Validator/Rules/ProvidedRequiredArgumentsOnDirectives.php
@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Validator\Rules;
+
+use GraphQL\Error\Error;
+use GraphQL\Language\AST\ArgumentNode;
+use GraphQL\Language\AST\DirectiveDefinitionNode;
+use GraphQL\Language\AST\DirectiveNode;
+use GraphQL\Language\AST\NamedTypeNode;
+use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\NodeKind;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Language\AST\NonNullTypeNode;
+use GraphQL\Type\Definition\FieldArgument;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Utils\Utils;
+use GraphQL\Validator\ValidationContext;
+use function array_filter;
+use function is_array;
+use function iterator_to_array;
+
+/**
+ * Provided required arguments on directives
+ *
+ * A directive is only valid if all required (non-null without a
+ * default value) field arguments have been provided.
+ */
+class ProvidedRequiredArgumentsOnDirectives extends ValidationRule
+{
+    protected static function missingDirectiveArgMessage(string $directiveName, string $argName)
+    {
+        return 'Directive "' . $directiveName . '" argument "' . $argName . '" is required but ont provided.';
+    }
+
+    public function getVisitor(ValidationContext $context)
+    {
+        $requiredArgsMap   = [];
+        $schema            = $context->getSchema();
+        $definedDirectives = $schema->getDirectives();
+
+        foreach ($definedDirectives as $directive) {
+            $requiredArgsMap[$directive->name] = Utils::keyMap(
+                array_filter($directive->args, static function (FieldArgument $arg) : bool {
+                    return $arg->getType() instanceof NonNull && ! isset($arg->defaultValue);
+                }),
+                static function (FieldArgument $arg) : string {
+                    return $arg->name;
+                }
+            );
+        }
+
+        $astDefinition = $context->getDocument()->definitions;
+        foreach ($astDefinition as $def) {
+            if (! ($def instanceof DirectiveDefinitionNode)) {
+                continue;
+            }
+
+            if (is_array($def->arguments)) {
+                $arguments = $def->arguments;
+            } elseif ($def->arguments instanceof NodeList) {
+                $arguments = iterator_to_array($def->arguments->getIterator());
+            } else {
+                $arguments = null;
+            }
+
+            $requiredArgsMap[$def->name->value] = Utils::keyMap(
+                $arguments ? array_filter($arguments, static function (Node $argument) : bool {
+                    return $argument instanceof NonNullTypeNode &&
+                        (
+                            ! isset($argument->defaultValue) ||
+                            $argument->defaultValue === null
+                        );
+                }) : [],
+                static function (NamedTypeNode $argument) : string {
+                    return $argument->name->value;
+                }
+            );
+        }
+
+        return [
+            NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($requiredArgsMap, $context) {
+                $directiveName = $directiveNode->name->value;
+                $requiredArgs  = $requiredArgsMap[$directiveName] ?? null;
+                if (! $requiredArgs) {
+                    return;
+                }
+
+                $argNodes   = $directiveNode->arguments ?: [];
+                $argNodeMap = Utils::keyMap(
+                    $argNodes,
+                    static function (ArgumentNode $arg) : string {
+                        return $arg->name->value;
+                    }
+                );
+
+                foreach ($requiredArgs as $argName => $arg) {
+                    if (isset($argNodeMap[$argName])) {
+                        continue;
+                    }
+
+                    $context->reportError(
+                        new Error(static::missingDirectiveArgMessage($directiveName, $argName), [$directiveNode])
+                    );
+                }
+            },
+        ];
+    }
+}
diff --git a/tests/Utils/SchemaExtenderTest.php b/tests/Utils/SchemaExtenderTest.php
new file mode 100644
index 0000000..552cc29
--- /dev/null
+++ b/tests/Utils/SchemaExtenderTest.php
@@ -0,0 +1,1931 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQL\Tests\Utils;
+
+use GraphQL\Error\Error;
+use GraphQL\GraphQL;
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Language\AST\Node;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Language\DirectiveLocation;
+use GraphQL\Language\Parser;
+use GraphQL\Language\Printer;
+use GraphQL\Type\Definition\CustomScalarType;
+use GraphQL\Type\Definition\Directive;
+use GraphQL\Type\Definition\EnumType;
+use GraphQL\Type\Definition\FieldArgument;
+use GraphQL\Type\Definition\InputObjectType;
+use GraphQL\Type\Definition\InterfaceType;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\ScalarType;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\UnionType;
+use GraphQL\Type\Schema;
+use GraphQL\Utils\SchemaExtender;
+use GraphQL\Utils\SchemaPrinter;
+use PHPUnit\Framework\TestCase;
+use function array_filter;
+use function array_map;
+use function array_merge;
+use function array_values;
+use function count;
+use function implode;
+use function in_array;
+use function iterator_to_array;
+use function preg_match;
+use function preg_replace;
+use function trim;
+use const PHP_EOL;
+
+class SchemaExtenderTest extends TestCase
+{
+    /** @var Schema */
+    protected $testSchema;
+
+    /** @var string[] */
+    protected $testSchemaDefinitions;
+
+    /** @var ObjectType */
+    protected $FooType;
+
+    /** @var Directive */
+    protected $FooDirective;
+
+    public function setUp()
+    {
+        parent::setUp();
+
+        $SomeScalarType = new CustomScalarType([
+            'name' => 'SomeScalar',
+            'serialize' => static function ($x) {
+                return $x;
+            },
+        ]);
+
+        $SomeInterfaceType = new InterfaceType([
+            'name' => 'SomeInterface',
+            'fields' => static function () use (&$SomeInterfaceType) {
+                return [
+                    'name' => [ 'type' => Type::string()],
+                    'some' => [ 'type' => $SomeInterfaceType],
+                ];
+            },
+        ]);
+
+        $FooType = new ObjectType([
+            'name' => 'Foo',
+            'interfaces' => [$SomeInterfaceType],
+            'fields' => static function () use ($SomeInterfaceType, &$FooType) {
+                return [
+                    'name' => [ 'type' => Type::string() ],
+                    'some' => [ 'type' => $SomeInterfaceType ],
+                    'tree' => [ 'type' => Type::nonNull(Type::listOf($FooType))],
+                ];
+            },
+        ]);
+
+        $BarType = new ObjectType([
+            'name' => 'Bar',
+            'interfaces' => [$SomeInterfaceType],
+            'fields' => static function () use ($SomeInterfaceType, $FooType) : array {
+                return [
+                    'name' => [ 'type' => Type::string() ],
+                    'some' => [ 'type' => $SomeInterfaceType ],
+                    'foo' => [ 'type' => $FooType ],
+                ];
+            },
+        ]);
+
+        $BizType = new ObjectType([
+            'name' => 'Biz',
+            'fields' => static function () : array {
+                return [
+                    'fizz' => [ 'type' => Type::string() ],
+                ];
+            },
+        ]);
+
+        $SomeUnionType = new UnionType([
+            'name' => 'SomeUnion',
+            'types' => [$FooType, $BizType],
+        ]);
+
+        $SomeEnumType = new EnumType([
+            'name' => 'SomeEnum',
+            'values' => [
+                'ONE' => [ 'value' => 1 ],
+                'TWO' => [ 'value' => 2 ],
+            ],
+        ]);
+
+        $SomeInputType = new InputObjectType([
+            'name' => 'SomeInput',
+            'fields' => static function () : array {
+                return [
+                    'fooArg' => [ 'type' => Type::string() ],
+                ];
+            },
+        ]);
+
+        $FooDirective = new Directive([
+            'name' => 'foo',
+            'args' => [
+                new FieldArgument([
+                    'name' => 'input',
+                    'type' => $SomeInputType,
+                ]),
+            ],
+            'locations' => [
+                DirectiveLocation::SCHEMA,
+                DirectiveLocation::SCALAR,
+                DirectiveLocation::OBJECT,
+                DirectiveLocation::FIELD_DEFINITION,
+                DirectiveLocation::ARGUMENT_DEFINITION,
+                DirectiveLocation::IFACE,
+                DirectiveLocation::UNION,
+                DirectiveLocation::ENUM,
+                DirectiveLocation::ENUM_VALUE,
+                DirectiveLocation::INPUT_OBJECT,
+                DirectiveLocation::INPUT_FIELD_DEFINITION,
+            ],
+        ]);
+
+        $this->testSchema = new Schema([
+            'query' => new ObjectType([
+                'name' => 'Query',
+                'fields' => static function () use ($FooType, $SomeScalarType, $SomeUnionType, $SomeEnumType, $SomeInterfaceType, $SomeInputType) : array {
+                    return [
+                        'foo' => [ 'type' => $FooType ],
+                        'someScalar' => [ 'type' => $SomeScalarType ],
+                        'someUnion' => [ 'type' => $SomeUnionType ],
+                        'someEnum' => [ 'type' => $SomeEnumType ],
+                        'someInterface' => [
+                            'args' => [
+                                'id' => [
+                                    'type' => Type::nonNull(Type::ID()),
+                                ],
+                            ],
+                            'type' => $SomeInterfaceType,
+                        ],
+                        'someInput' => [
+                            'args' => [ 'input' => [ 'type' => $SomeInputType ] ],
+                            'type' => Type::string(),
+                        ],
+                    ];
+                },
+            ]),
+            'types' => [$FooType, $BarType],
+            'directives' => array_merge(GraphQL::getStandardDirectives(), [$FooDirective]),
+        ]);
+
+        $testSchemaAst = Parser::parse(SchemaPrinter::doPrint($this->testSchema));
+
+        $this->testSchemaDefinitions = array_map(static function ($node) {
+            return Printer::doPrint($node);
+        }, iterator_to_array($testSchemaAst->definitions->getIterator()));
+
+        $this->FooDirective = $FooDirective;
+        $this->FooType      = $FooType;
+    }
+
+    protected function dedent(string $str) : string
+    {
+        $trimmedStr = trim($str, "\n");
+        $trimmedStr = preg_replace('/[ \t]*$/', '', $trimmedStr);
+
+        preg_match('/^[ \t]*/', $trimmedStr, $indentMatch);
+        $indent = $indentMatch[0];
+        return preg_replace('/^' . $indent . '/m', '', $trimmedStr);
+    }
+
+    /**
+     * @param mixed[]|null $options
+     */
+    protected function extendTestSchema(string $sdl, ?array $options = null) : Schema
+    {
+        $originalPrint  = SchemaPrinter::doPrint($this->testSchema);
+        $ast            = Parser::parse($sdl);
+        $extendedSchema = SchemaExtender::extend($this->testSchema, $ast, $options);
+        self::assertEquals(SchemaPrinter::doPrint($this->testSchema), $originalPrint);
+        return $extendedSchema;
+    }
+
+    protected function printTestSchemaChanges(Schema $extendedSchema) : string
+    {
+        $ast              = Parser::parse(SchemaPrinter::doPrint($extendedSchema));
+        $ast->definitions = array_values(array_filter(
+            $ast->definitions instanceof NodeList ? iterator_to_array($ast->definitions->getIterator()) : $ast->definitions,
+            function (Node $node) : bool {
+                return ! in_array(Printer::doPrint($node), $this->testSchemaDefinitions);
+            }
+        ));
+
+        return Printer::doPrint($ast);
+    }
+
+    /**
+     * @see it('returns the original schema when there are no type definitions')
+     */
+    public function testReturnsTheOriginalSchemaWhenThereAreNoTypeDefinitions()
+    {
+        $extendedSchema = $this->extendTestSchema('{ field }');
+        self::assertEquals($extendedSchema, $this->testSchema);
+    }
+
+    /**
+     * @see it('extends without altering original schema')
+     */
+    public function testExtendsWithoutAlteringOriginalSchema()
+    {
+        $extendedSchema = $this->extendTestSchema('
+            extend type Query {
+                newField: String
+            }');
+        self::assertNotEquals($extendedSchema, $this->testSchema);
+        self::assertContains('newField', SchemaPrinter::doPrint($extendedSchema));
+        self::assertNotContains('newField', SchemaPrinter::doPrint($this->testSchema));
+    }
+
+    /**
+     * @see it('can be used for limited execution')
+     */
+    public function testCanBeUsedForLimitedExecution()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Query {
+            newField: String
+          }
+        ');
+
+        $result = GraphQL::executeQuery($extendedSchema, '{ newField }', ['newField' => 123]);
+
+        self::assertEquals($result->toArray(), [
+            'data' => ['newField' => '123'],
+        ]);
+    }
+
+    /**
+     * @see it('can describe the extended fields')
+     */
+    public function testCanDescribeTheExtendedFields()
+    {
+        $extendedSchema = $this->extendTestSchema('
+            extend type Query {
+                "New field description."
+                newField: String
+            }
+        ');
+
+        self::assertEquals(
+            $extendedSchema->getQueryType()->getField('newField')->description,
+            'New field description.'
+        );
+    }
+
+    /**
+     * @see it('can describe the extended fields with legacy comments')
+     */
+    public function testCanDescribeTheExtendedFieldsWithLegacyComments()
+    {
+        $extendedSchema = $this->extendTestSchema('
+            extend type Query {
+                # New field description.
+                newField: String
+            }
+        ', ['commentDescriptions' => true]);
+
+        self::assertEquals(
+            $extendedSchema->getQueryType()->getField('newField')->description,
+            'New field description.'
+        );
+    }
+
+    /**
+     * @see it('describes extended fields with strings when present')
+     */
+    public function testDescribesExtendedFieldsWithStringsWhenPresent()
+    {
+        $extendedSchema = $this->extendTestSchema('
+            extend type Query {
+                # New field description.
+                "Actually use this description."
+                newField: String
+            }
+        ', ['commentDescriptions' => true ]);
+
+        self::assertEquals(
+            $extendedSchema->getQueryType()->getField('newField')->description,
+            'Actually use this description.'
+        );
+    }
+
+    /**
+     * @see it('extends objects by adding new fields')
+     */
+    public function testExtendsObjectsByAddingNewFields()
+    {
+        $extendedSchema = $this->extendTestSchema(
+            '
+            extend type Foo {
+                newField: String
+            }
+        '
+        );
+
+        self::assertEquals(
+            $this->printTestSchemaChanges($extendedSchema),
+            $this->dedent('
+              type Foo implements SomeInterface {
+                name: String
+                some: SomeInterface
+                tree: [Foo]!
+                newField: String
+              }
+            ')
+        );
+
+        $fooType  = $extendedSchema->getType('Foo');
+        $fooField = $extendedSchema->getQueryType()->getField('foo');
+        self::assertEquals($fooField->getType(), $fooType);
+    }
+
+    /**
+     * @see it('extends enums by adding new values')
+     */
+    public function testExtendsEnumsByAddingNewValues()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend enum SomeEnum {
+            NEW_ENUM
+          }
+        ');
+
+        self::assertEquals(
+            $this->printTestSchemaChanges($extendedSchema),
+            $this->dedent('
+              enum SomeEnum {
+                ONE
+                TWO
+                NEW_ENUM
+              }
+          ')
+        );
+
+        $someEnumType = $extendedSchema->getType('SomeEnum');
+        $enumField    = $extendedSchema->getQueryType()->getField('someEnum');
+        self::assertEquals($enumField->getType(), $someEnumType);
+    }
+
+    /**
+     * @see it('extends unions by adding new types')
+     */
+    public function testExtendsUnionsByAddingNewTypes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend union SomeUnion = Bar
+        ');
+        self::assertEquals(
+            $this->printTestSchemaChanges($extendedSchema),
+            $this->dedent('
+              union SomeUnion = Foo | Biz | Bar
+            ')
+        );
+
+        $someUnionType = $extendedSchema->getType('SomeUnion');
+        $unionField    = $extendedSchema->getQueryType()->getField('someUnion');
+        self::assertEquals($unionField->getType(), $someUnionType);
+    }
+
+    /**
+     * @see it('allows extension of union by adding itself')
+     */
+    public function testAllowsExtensionOfUnionByAddingItself()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend union SomeUnion = SomeUnion
+        ');
+
+        $errors = $extendedSchema->validate();
+        self::assertGreaterThan(0, count($errors));
+
+        self::assertEquals(
+            $this->printTestSchemaChanges($extendedSchema),
+            $this->dedent('
+                union SomeUnion = Foo | Biz | SomeUnion
+            ')
+        );
+    }
+
+    /**
+     * @see it('extends inputs by adding new fields')
+     */
+    public function testExtendsInputsByAddingNewFields()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend input SomeInput {
+            newField: String
+          }
+        ');
+
+        self::assertEquals(
+            $this->printTestSchemaChanges($extendedSchema),
+            $this->dedent('
+              input SomeInput {
+                fooArg: String
+                newField: String
+              }
+            ')
+        );
+
+        $someInputType = $extendedSchema->getType('SomeInput');
+        $inputField    = $extendedSchema->getQueryType()->getField('someInput');
+        self::assertEquals($inputField->args[0]->getType(), $someInputType);
+
+        $fooDirective = $extendedSchema->getDirective('foo');
+        self::assertEquals($fooDirective->args[0]->getType(), $someInputType);
+    }
+
+    /**
+     * @see it('extends scalars by adding new directives')
+     */
+    public function testExtendsScalarsByAddingNewDirectives()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend scalar SomeScalar @foo
+        ');
+
+        $someScalar = $extendedSchema->getType('SomeScalar');
+        self::assertCount(1, $someScalar->extensionASTNodes);
+        self::assertEquals(
+            Printer::doPrint($someScalar->extensionASTNodes[0]),
+            'extend scalar SomeScalar @foo'
+        );
+    }
+
+    /**
+     * @see it('correctly assign AST nodes to new and extended types')
+     */
+    public function testCorrectlyAssignASTNodesToNewAndExtendedTypes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+              extend type Query {
+                newField(testArg: TestInput): TestEnum
+              }
+              extend scalar SomeScalar @foo
+              extend enum SomeEnum {
+                NEW_VALUE
+              }
+              extend union SomeUnion = Bar
+              extend input SomeInput {
+                newField: String
+              }
+              extend interface SomeInterface {
+                newField: String
+              }
+              enum TestEnum {
+                TEST_VALUE
+              }
+              input TestInput {
+                testInputField: TestEnum
+              }
+            ');
+
+        $ast = Parser::parse('
+            extend type Query {
+                oneMoreNewField: TestUnion
+            }
+            extend scalar SomeScalar @test
+            extend enum SomeEnum {
+                ONE_MORE_NEW_VALUE
+            }
+            extend union SomeUnion = TestType
+            extend input SomeInput {
+                oneMoreNewField: String
+            }
+            extend interface SomeInterface {
+                oneMoreNewField: String
+            }
+            union TestUnion = TestType
+            interface TestInterface {
+                interfaceField: String
+            }
+            type TestType implements TestInterface {
+                interfaceField: String
+            }
+            directive @test(arg: Int) on FIELD | SCALAR
+        ');
+
+        $extendedTwiceSchema = SchemaExtender::extend($extendedSchema, $ast);
+        $query               = $extendedTwiceSchema->getQueryType();
+        /** @var ScalarType $someScalar */
+        $someScalar = $extendedTwiceSchema->getType('SomeScalar');
+        /** @var EnumType $someEnum */
+        $someEnum = $extendedTwiceSchema->getType('SomeEnum');
+        /** @var UnionType $someUnion */
+        $someUnion = $extendedTwiceSchema->getType('SomeUnion');
+        /** @var InputObjectType $someInput */
+        $someInput = $extendedTwiceSchema->getType('SomeInput');
+        /** @var InterfaceType $someInterface */
+        $someInterface = $extendedTwiceSchema->getType('SomeInterface');
+
+        /** @var InputObjectType $testInput */
+        $testInput = $extendedTwiceSchema->getType('TestInput');
+        /** @var EnumType $testEnum */
+        $testEnum = $extendedTwiceSchema->getType('TestEnum');
+        /** @var UnionType $testUnion */
+        $testUnion = $extendedTwiceSchema->getType('TestUnion');
+        /** @var InterfaceType $testInterface */
+        $testInterface = $extendedTwiceSchema->getType('TestInterface');
+        /** @var ObjectType $testType */
+        $testType = $extendedTwiceSchema->getType('TestType');
+        /** @var Directive $testDirective */
+        $testDirective = $extendedTwiceSchema->getDirective('test');
+
+        self::assertCount(2, $query->extensionASTNodes);
+        self::assertCount(2, $someScalar->extensionASTNodes);
+        self::assertCount(2, $someEnum->extensionASTNodes);
+        self::assertCount(2, $someUnion->extensionASTNodes);
+        self::assertCount(2, $someInput->extensionASTNodes);
+        self::assertCount(2, $someInterface->extensionASTNodes);
+
+        self::assertCount(0, $testType->extensionASTNodes ?? []);
+        self::assertCount(0, $testEnum->extensionASTNodes ?? []);
+        self::assertCount(0, $testUnion->extensionASTNodes ?? []);
+        self::assertCount(0, $testInput->extensionASTNodes ?? []);
+        self::assertCount(0, $testInterface->extensionASTNodes ?? []);
+
+        $restoredExtensionAST = new DocumentNode([
+            'definitions' => array_merge(
+                $query->extensionASTNodes,
+                $someScalar->extensionASTNodes,
+                $someEnum->extensionASTNodes,
+                $someUnion->extensionASTNodes,
+                $someInput->extensionASTNodes,
+                $someInterface->extensionASTNodes,
+                [
+                    $testInput->astNode,
+                    $testEnum->astNode,
+                    $testUnion->astNode,
+                    $testInterface->astNode,
+                    $testType->astNode,
+                    $testDirective->astNode,
+                ]
+            ),
+        ]);
+
+        self::assertEquals(
+            SchemaPrinter::doPrint(SchemaExtender::extend($this->testSchema, $restoredExtensionAST)),
+            SchemaPrinter::doPrint($extendedTwiceSchema)
+        );
+
+        $newField = $query->getField('newField');
+
+        self::assertEquals(Printer::doPrint($newField->astNode), 'newField(testArg: TestInput): TestEnum');
+        self::assertEquals(Printer::doPrint($newField->args[0]->astNode), 'testArg: TestInput');
+        self::assertEquals(Printer::doPrint($query->getField('oneMoreNewField')->astNode), 'oneMoreNewField: TestUnion');
+        self::assertEquals(Printer::doPrint($someEnum->getValue('NEW_VALUE')->astNode), 'NEW_VALUE');
+        self::assertEquals(Printer::doPrint($someEnum->getValue('ONE_MORE_NEW_VALUE')->astNode), 'ONE_MORE_NEW_VALUE');
+        self::assertEquals(Printer::doPrint($someInput->getField('newField')->astNode), 'newField: String');
+        self::assertEquals(Printer::doPrint($someInput->getField('oneMoreNewField')->astNode), 'oneMoreNewField: String');
+        self::assertEquals(Printer::doPrint($someInterface->getField('newField')->astNode), 'newField: String');
+        self::assertEquals(Printer::doPrint($someInterface->getField('oneMoreNewField')->astNode), 'oneMoreNewField: String');
+        self::assertEquals(Printer::doPrint($testInput->getField('testInputField')->astNode), 'testInputField: TestEnum');
+        self::assertEquals(Printer::doPrint($testEnum->getValue('TEST_VALUE')->astNode), 'TEST_VALUE');
+        self::assertEquals(Printer::doPrint($testInterface->getField('interfaceField')->astNode), 'interfaceField: String');
+        self::assertEquals(Printer::doPrint($testType->getField('interfaceField')->astNode), 'interfaceField: String');
+        self::assertEquals(Printer::doPrint($testDirective->args[0]->astNode), 'arg: Int');
+    }
+
+    /**
+     * @see it('builds types with deprecated fields/values')
+     */
+    public function testBuildsTypesWithDeprecatedFieldsOrValues()
+    {
+        $extendedSchema = $this->extendTestSchema('
+            type TypeWithDeprecatedField {
+                newDeprecatedField: String @deprecated(reason: "not used anymore")
+            }
+            enum EnumWithDeprecatedValue {
+                DEPRECATED @deprecated(reason: "do not use")
+            }
+        ');
+
+        /** @var ObjectType $typeWithDeprecatedField */
+        $typeWithDeprecatedField = $extendedSchema->getType('TypeWithDeprecatedField');
+        $deprecatedFieldDef      = $typeWithDeprecatedField->getField('newDeprecatedField');
+
+        self::assertEquals(true, $deprecatedFieldDef->isDeprecated());
+        self::assertEquals('not used anymore', $deprecatedFieldDef->deprecationReason);
+
+        /** @var EnumType $enumWithDeprecatedValue */
+        $enumWithDeprecatedValue = $extendedSchema->getType('EnumWithDeprecatedValue');
+        $deprecatedEnumDef       = $enumWithDeprecatedValue->getValue('DEPRECATED');
+
+        self::assertEquals(true, $deprecatedEnumDef->isDeprecated());
+        self::assertEquals('do not use', $deprecatedEnumDef->deprecationReason);
+    }
+
+    /**
+     * @see it('extends objects with deprecated fields')
+     */
+    public function testExtendsObjectsWithDeprecatedFields()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Foo {
+            deprecatedField: String @deprecated(reason: "not used anymore")
+          }
+        ');
+        /** @var ObjectType $fooType */
+        $fooType            = $extendedSchema->getType('Foo');
+        $deprecatedFieldDef = $fooType->getField('deprecatedField');
+
+        self::assertTrue($deprecatedFieldDef->isDeprecated());
+        self::assertEquals('not used anymore', $deprecatedFieldDef->deprecationReason);
+    }
+
+    /**
+     * @see it('extends enums with deprecated values')
+     */
+    public function testExtendsEnumsWithDeprecatedValues()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend enum SomeEnum {
+            DEPRECATED @deprecated(reason: "do not use")
+          }
+        ');
+
+        /** @var EnumType $someEnumType */
+        $someEnumType      = $extendedSchema->getType('SomeEnum');
+        $deprecatedEnumDef = $someEnumType->getValue('DEPRECATED');
+
+        self::assertTrue($deprecatedEnumDef->isDeprecated());
+        self::assertEquals('do not use', $deprecatedEnumDef->deprecationReason);
+    }
+
+    /**
+     * @see it('adds new unused object type')
+     */
+    public function testAddsNewUnusedObjectType()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          type Unused {
+            someField: String
+          }
+        ');
+        self::assertNotEquals($this->testSchema, $extendedSchema);
+        self::assertEquals(
+            $this->dedent('
+                type Unused {
+                  someField: String
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('adds new unused enum type')
+     */
+    public function testAddsNewUnusedEnumType()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          enum UnusedEnum {
+            SOME
+          }
+        ');
+        self::assertNotEquals($extendedSchema, $this->testSchema);
+        self::assertEquals(
+            $this->dedent('
+                enum UnusedEnum {
+                  SOME
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('adds new unused input object type')
+     */
+    public function testAddsNewUnusedInputObjectType()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          input UnusedInput {
+            someInput: String
+          }
+        ');
+
+        self::assertNotEquals($extendedSchema, $this->testSchema);
+        self::assertEquals(
+            $this->dedent('
+              input UnusedInput {
+                someInput: String
+              }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('adds new union using new object type')
+     */
+    public function testAddsNewUnionUsingNewObjectType()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          type DummyUnionMember {
+            someField: String
+          }
+
+          union UnusedUnion = DummyUnionMember
+        ');
+
+        self::assertNotEquals($extendedSchema, $this->testSchema);
+        self::assertEquals(
+            $this->dedent('
+              type DummyUnionMember {
+                someField: String
+              }
+
+              union UnusedUnion = DummyUnionMember
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends objects by adding new fields with arguments')
+     */
+    public function testExtendsObjectsByAddingNewFieldsWithArguments()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Foo {
+            newField(arg1: String, arg2: NewInputObj!): String
+          }
+
+          input NewInputObj {
+            field1: Int
+            field2: [Float]
+            field3: String!
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Foo implements SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  tree: [Foo]!
+                  newField(arg1: String, arg2: NewInputObj!): String
+                }
+
+                input NewInputObj {
+                  field1: Int
+                  field2: [Float]
+                  field3: String!
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends objects by adding new fields with existing types')
+     */
+    public function testExtendsObjectsByAddingNewFieldsWithExistingTypes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Foo {
+            newField(arg1: SomeEnum!): SomeEnum
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Foo implements SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  tree: [Foo]!
+                  newField(arg1: SomeEnum!): SomeEnum
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends objects by adding implemented interfaces')
+     */
+    public function testExtendsObjectsByAddingImplementedInterfaces()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Biz implements SomeInterface {
+            name: String
+            some: SomeInterface
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Biz implements SomeInterface {
+                  fizz: String
+                  name: String
+                  some: SomeInterface
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends objects by including new types')
+     */
+    public function testExtendsObjectsByIncludingNewTypes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Foo {
+            newObject: NewObject
+            newInterface: NewInterface
+            newUnion: NewUnion
+            newScalar: NewScalar
+            newEnum: NewEnum
+            newTree: [Foo]!
+          }
+
+          type NewObject implements NewInterface {
+            baz: String
+          }
+
+          type NewOtherObject {
+            fizz: Int
+          }
+
+          interface NewInterface {
+            baz: String
+          }
+
+          union NewUnion = NewObject | NewOtherObject
+
+          scalar NewScalar
+
+          enum NewEnum {
+            OPTION_A
+            OPTION_B
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Foo implements SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  tree: [Foo]!
+                  newObject: NewObject
+                  newInterface: NewInterface
+                  newUnion: NewUnion
+                  newScalar: NewScalar
+                  newEnum: NewEnum
+                  newTree: [Foo]!
+                }
+
+                enum NewEnum {
+                  OPTION_A
+                  OPTION_B
+                }
+
+                interface NewInterface {
+                  baz: String
+                }
+
+                type NewObject implements NewInterface {
+                  baz: String
+                }
+
+                type NewOtherObject {
+                  fizz: Int
+                }
+
+                scalar NewScalar
+
+                union NewUnion = NewObject | NewOtherObject
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends objects by adding implemented new interfaces')
+     */
+    public function testExtendsObjectsByAddingImplementedNewInterfaces()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Foo implements NewInterface {
+            baz: String
+          }
+
+          interface NewInterface {
+            baz: String
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Foo implements SomeInterface & NewInterface {
+                  name: String
+                  some: SomeInterface
+                  tree: [Foo]!
+                  baz: String
+                }
+
+                interface NewInterface {
+                  baz: String
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends different types multiple times')
+     */
+    public function testExtendsDifferentTypesMultipleTimes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend type Biz implements NewInterface {
+            buzz: String
+          }
+
+          extend type Biz implements SomeInterface {
+            name: String
+            some: SomeInterface
+            newFieldA: Int
+          }
+
+          extend type Biz {
+            newFieldA: Int
+            newFieldB: Float
+          }
+
+          interface NewInterface {
+            buzz: String
+          }
+
+          extend enum SomeEnum {
+            THREE
+          }
+
+          extend enum SomeEnum {
+            FOUR
+          }
+
+          extend union SomeUnion = Boo
+
+          extend union SomeUnion = Joo
+
+          type Boo {
+            fieldA: String
+          }
+
+          type Joo {
+            fieldB: String
+          }
+
+          extend input SomeInput {
+            fieldA: String
+          }
+
+          extend input SomeInput {
+            fieldB: String
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Biz implements NewInterface & SomeInterface {
+                  fizz: String
+                  buzz: String
+                  name: String
+                  some: SomeInterface
+                  newFieldA: Int
+                  newFieldB: Float
+                }
+
+                type Boo {
+                  fieldA: String
+                }
+
+                type Joo {
+                  fieldB: String
+                }
+
+                interface NewInterface {
+                  buzz: String
+                }
+
+                enum SomeEnum {
+                  ONE
+                  TWO
+                  THREE
+                  FOUR
+                }
+
+                input SomeInput {
+                  fooArg: String
+                  fieldA: String
+                  fieldB: String
+                }
+
+                union SomeUnion = Foo | Biz | Boo | Joo
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends interfaces by adding new fields')
+     */
+    public function testExtendsInterfacesByAddingNewFields()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend interface SomeInterface {
+            newField: String
+          }
+
+          extend type Bar {
+            newField: String
+          }
+
+          extend type Foo {
+            newField: String
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                type Bar implements SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  foo: Foo
+                  newField: String
+                }
+
+                type Foo implements SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  tree: [Foo]!
+                  newField: String
+                }
+
+                interface SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  newField: String
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('allows extension of interface with missing Object fields')
+     */
+    public function testAllowsExtensionOfInterfaceWithMissingObjectFields()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend interface SomeInterface {
+            newField: String
+          }
+        ');
+
+        $errors = $extendedSchema->validate();
+        self::assertGreaterThan(0, $errors);
+
+        self::assertEquals(
+            $this->dedent('
+                interface SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  newField: String
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('extends interfaces multiple times')
+     */
+    public function testExtendsInterfacesMultipleTimes()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          extend interface SomeInterface {
+            newFieldA: Int
+          }
+          extend interface SomeInterface {
+            newFieldB(test: Boolean): String
+          }
+        ');
+
+        self::assertEquals(
+            $this->dedent('
+                interface SomeInterface {
+                  name: String
+                  some: SomeInterface
+                  newFieldA: Int
+                  newFieldB(test: Boolean): String
+                }
+            '),
+            $this->printTestSchemaChanges($extendedSchema)
+        );
+    }
+
+    /**
+     * @see it('may extend mutations and subscriptions')
+     */
+    public function testMayExtendMutationsAndSubscriptions()
+    {
+        $mutationSchema = new Schema([
+            'query' => new ObjectType([
+                'name' => 'Query',
+                'fields' => static function () {
+                    return [ 'queryField' => [ 'type' => Type::string() ] ];
+                },
+            ]),
+            'mutation' => new ObjectType([
+                'name' => 'Mutation',
+                'fields' => static function () {
+                    return [ 'mutationField' => ['type' => Type::string() ] ];
+                },
+            ]),
+            'subscription' => new ObjectType([
+                'name' => 'Subscription',
+                'fields' => static function () {
+                    return ['subscriptionField' => ['type' => Type::string()]];
+                },
+            ]),
+        ]);
+
+        $ast = Parser::parse('
+            extend type Query {
+              newQueryField: Int
+            }
+
+            extend type Mutation {
+              newMutationField: Int
+            }
+
+            extend type Subscription {
+              newSubscriptionField: Int
+            }
+        ');
+
+        $originalPrint  = SchemaPrinter::doPrint($mutationSchema);
+        $extendedSchema = SchemaExtender::extend($mutationSchema, $ast);
+        self::assertNotEquals($mutationSchema, $extendedSchema);
+        self::assertEquals(SchemaPrinter::doPrint($mutationSchema), $originalPrint);
+        self::assertEquals(SchemaPrinter::doPrint($extendedSchema), $this->dedent('
+            type Mutation {
+              mutationField: String
+              newMutationField: Int
+            }
+
+            type Query {
+              queryField: String
+              newQueryField: Int
+            }
+
+            type Subscription {
+              subscriptionField: String
+              newSubscriptionField: Int
+            }
+        '));
+    }
+
+    /**
+     * @see it('may extend directives with new simple directive')
+     */
+    public function testMayExtendDirectivesWithNewSimpleDirective()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          directive @neat on QUERY
+        ');
+
+        $newDirective = $extendedSchema->getDirective('neat');
+        self::assertEquals($newDirective->name, 'neat');
+        self::assertContains('QUERY', $newDirective->locations);
+    }
+
+    /**
+     * @see it('sets correct description when extending with a new directive')
+     */
+    public function testSetsCorrectDescriptionWhenExtendingWithANewDirective()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          """
+          new directive
+          """
+          directive @new on QUERY
+        ');
+
+        $newDirective = $extendedSchema->getDirective('new');
+        self::assertEquals('new directive', $newDirective->description);
+    }
+
+    /**
+     * @see it('sets correct description using legacy comments')
+     */
+    public function testSetsCorrectDescriptionUsingLegacyComments()
+    {
+        $extendedSchema = $this->extendTestSchema(
+            '
+          # new directive
+          directive @new on QUERY
+        ',
+            [ 'commentDescriptions' => true ]
+        );
+
+        $newDirective = $extendedSchema->getDirective('new');
+        self::assertEquals('new directive', $newDirective->description);
+    }
+
+
+    /**
+     * @see it('may extend directives with new complex directive')
+     */
+    public function testMayExtendDirectivesWithNewComplexDirective()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          directive @profile(enable: Boolean! tag: String) on QUERY | FIELD
+        ');
+
+        $extendedDirective = $extendedSchema->getDirective('profile');
+        self::assertContains('QUERY', $extendedDirective->locations);
+        self::assertContains('FIELD', $extendedDirective->locations);
+
+        $args = $extendedDirective->args;
+        self::assertCount(2, $args);
+
+        $arg0 = $args[0];
+        $arg1 = $args[1];
+        /** @var NonNull $arg0Type */
+        $arg0Type = $arg0->getType();
+
+        self::assertEquals('enable', $arg0->name);
+        self::assertTrue($arg0Type instanceof NonNull);
+        self::assertTrue($arg0Type->getWrappedType() instanceof ScalarType);
+
+        self::assertEquals('tag', $arg1->name);
+        self::assertTrue($arg1->getType() instanceof ScalarType);
+    }
+
+    /**
+     * @see it('Rejects invalid SDL')
+     */
+    public function testRejectsInvalidSDL()
+    {
+        $sdl = '
+            extend schema @unknown
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Unknown directive "unknown".', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('Allows to disable SDL validation')
+     */
+    public function testAllowsToDisableSDLValidation()
+    {
+        $sdl = '
+          extend schema @unknown
+        ';
+
+        $this->extendTestSchema($sdl, [ 'assumeValid' => true ]);
+        $this->extendTestSchema($sdl, [ 'assumeValidSDL' => true ]);
+    }
+
+    /**
+     * @see it('does not allow replacing a default directive')
+     */
+    public function testDoesNotAllowReplacingADefaultDirective()
+    {
+        $sdl = '
+          directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Directive "include" already exists in the schema. It cannot be redefined.', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow replacing a custom directive')
+     */
+    public function testDoesNotAllowReplacingACustomDirective()
+    {
+        $extendedSchema = $this->extendTestSchema('
+          directive @meow(if: Boolean!) on FIELD | FRAGMENT_SPREAD
+        ');
+
+        $replacementAST = Parser::parse('
+            directive @meow(if: Boolean!) on FIELD | QUERY
+        ');
+
+        try {
+            SchemaExtender::extend($extendedSchema, $replacementAST);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Directive "meow" already exists in the schema. It cannot be redefined.', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow replacing an existing type')
+     */
+    public function testDoesNotAllowReplacingAnExistingType()
+    {
+        $existingTypeError = static function ($type) {
+            return 'Type "' . $type . '" already exists in the schema. It cannot also be defined in this type definition.';
+        };
+
+        $typeSDL = '
+            type Bar
+        ';
+
+        try {
+            $this->extendTestSchema($typeSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('Bar'), $error->getMessage());
+        }
+
+        $scalarSDL = '
+          scalar SomeScalar
+        ';
+
+        try {
+            $this->extendTestSchema($scalarSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('SomeScalar'), $error->getMessage());
+        }
+
+        $interfaceSDL = '
+          interface SomeInterface
+        ';
+
+        try {
+            $this->extendTestSchema($interfaceSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('SomeInterface'), $error->getMessage());
+        }
+
+        $enumSDL = '
+          enum SomeEnum
+        ';
+
+        try {
+            $this->extendTestSchema($enumSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('SomeEnum'), $error->getMessage());
+        }
+
+        $unionSDL = '
+          union SomeUnion
+        ';
+
+        try {
+            $this->extendTestSchema($unionSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('SomeUnion'), $error->getMessage());
+        }
+
+        $inputSDL = '
+          input SomeInput
+        ';
+
+        try {
+            $this->extendTestSchema($inputSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingTypeError('SomeInput'), $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow replacing an existing field')
+     */
+    public function testDoesNotAllowReplacingAnExistingField()
+    {
+        $existingFieldError = static function (string $type, string $field) {
+            return 'Field "' . $type . '.' . $field . '" already exists in the schema. It cannot also be defined in this type extension.';
+        };
+
+        $typeSDL = '
+          extend type Bar {
+            foo: Foo
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($typeSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingFieldError('Bar', 'foo'), $error->getMessage());
+        }
+
+        $interfaceSDL = '
+          extend interface SomeInterface {
+            some: Foo
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($interfaceSDL);
+            self::fail();
+        } catch (Error  $error) {
+            self::assertEquals($existingFieldError('SomeInterface', 'some'), $error->getMessage());
+        }
+
+        $inputSDL = '
+          extend input SomeInput {
+            fooArg: String
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($inputSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($existingFieldError('SomeInput', 'fooArg'), $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow replacing an existing enum value')
+     */
+    public function testDoesNotAllowReplacingAnExistingEnumValue()
+    {
+        $sdl = '
+          extend enum SomeEnum {
+            ONE
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Enum value "SomeEnum.ONE" already exists in the schema. It cannot also be defined in this type extension.', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow referencing an unknown type')
+     */
+    public function testDoesNotAllowReferencingAnUnknownType()
+    {
+        $unknownTypeError = 'Unknown type: "Quix". Ensure that this type exists either in the original schema, or is added in a type definition.';
+
+        $typeSDL = '
+          extend type Bar {
+            quix: Quix
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($typeSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($unknownTypeError, $error->getMessage());
+        }
+
+        $interfaceSDL = '
+          extend interface SomeInterface {
+            quix: Quix
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($interfaceSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($unknownTypeError, $error->getMessage());
+        }
+
+        $unionSDL = '
+          extend union SomeUnion = Quix
+        ';
+
+        try {
+            $this->extendTestSchema($unionSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($unknownTypeError, $error->getMessage());
+        }
+
+        $inputSDL = '
+          extend input SomeInput {
+            quix: Quix
+          }
+        ';
+
+        try {
+            $this->extendTestSchema($inputSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals($unknownTypeError, $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow extending an unknown type')
+     */
+    public function testDoesNotAllowExtendingAnUnknownType()
+    {
+        $sdls = [
+            'extend scalar UnknownType @foo',
+            'extend type UnknownType @foo',
+            'extend interface UnknownType @foo',
+            'extend enum UnknownType @foo',
+            'extend union UnknownType @foo',
+            'extend input UnknownType @foo',
+        ];
+
+        foreach ($sdls as $sdl) {
+            try {
+                $this->extendTestSchema($sdl);
+                self::fail();
+            } catch (Error $error) {
+                self::assertEquals('Cannot extend type "UnknownType" because it does not exist in the existing schema.', $error->getMessage());
+            }
+        }
+    }
+
+    /**
+     * @see it('maintains configuration of the original schema object')
+     */
+    public function testMaintainsConfigurationOfTheOriginalSchemaObject()
+    {
+        $this->markTestSkipped('allowedLegacyNames currently not supported');
+
+        $testSchemaWithLegacyNames = new Schema(
+            [
+                'query' => new ObjectType([
+                    'name' => 'Query',
+                    'fields' => static function () {
+                        return ['id' => ['type' => Type::ID()]];
+                    },
+                ]),
+            ]/*,
+            [ 'allowedLegacyNames' => ['__badName'] ]
+            */
+        );
+
+        $ast    = Parser::parse('
+            extend type Query {
+                __badName: String
+            }
+        ');
+        $schema = SchemaExtender::extend($testSchemaWithLegacyNames, $ast);
+        self::assertEquals(['__badName'], $schema->__allowedLegacyNames);
+    }
+
+    /**
+     * @see it('adds to the configuration of the original schema object')
+     */
+    public function testAddsToTheConfigurationOfTheOriginalSchemaObject()
+    {
+        $this->markTestSkipped('allowedLegacyNames currently not supported');
+
+        $testSchemaWithLegacyNames = new Schema(
+            [
+                'query' => new ObjectType([
+                    'name' => 'Query',
+                    'fields' => static function () {
+                        return ['__badName' => ['type' => Type::string()]];
+                    },
+                ]),
+            ]/*,
+            ['allowedLegacyNames' => ['__badName']]
+            */
+        );
+
+        $ast = Parser::parse('
+          extend type Query {
+            __anotherBadName: String
+          }
+        ');
+
+        $schema = SchemaExtender::extend($testSchemaWithLegacyNames, $ast, [
+            'allowedLegacyNames' => ['__anotherBadName'],
+        ]);
+
+        self::assertEquals(['__badName', '__anotherBadName'], $schema->__allowedLegacyNames);
+    }
+
+    /**
+     * @see it('does not allow extending a mismatch type')
+     */
+    public function testDoesNotAllowExtendingAMismatchType()
+    {
+        $typeSDL = '
+          extend type SomeInterface @foo
+        ';
+
+        try {
+            $this->extendTestSchema($typeSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Cannot extend non-object type "SomeInterface".', $error->getMessage());
+        }
+
+        $interfaceSDL = '
+          extend interface Foo @foo
+        ';
+
+        try {
+            $this->extendTestSchema($interfaceSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Cannot extend non-interface type "Foo".', $error->getMessage());
+        }
+
+        $enumSDL = '
+          extend enum Foo @foo
+        ';
+
+        try {
+            $this->extendTestSchema($enumSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Cannot extend non-enum type "Foo".', $error->getMessage());
+        }
+
+        $unionSDL = '
+          extend union Foo @foo
+        ';
+
+        try {
+            $this->extendTestSchema($unionSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Cannot extend non-union type "Foo".', $error->getMessage());
+        }
+
+        $inputSDL = '
+          extend input Foo @foo
+        ';
+
+        try {
+            $this->extendTestSchema($inputSDL);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Cannot extend non-input object type "Foo".', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not automatically include common root type names')
+     */
+    public function testDoesNotAutomaticallyIncludeCommonRootTypeNames()
+    {
+        $schema = $this->extendTestSchema('
+            type Mutation {
+              doSomething: String
+            }
+        ');
+
+        self::assertNull($schema->getMutationType());
+    }
+
+    /**
+     * @see it('adds schema definition missing in the original schema')
+     */
+    public function testAddsSchemaDefinitionMissingInTheOriginalSchema()
+    {
+        $schema = new Schema([
+            'directives' => [$this->FooDirective],
+            'types' => [$this->FooType],
+        ]);
+
+        self::assertNull($schema->getQueryType());
+
+        $ast = Parser::parse('
+            schema @foo {
+              query: Foo
+            }
+        ');
+
+        $schema    = SchemaExtender::extend($schema, $ast);
+        $queryType = $schema->getQueryType();
+
+        self::assertEquals($queryType->name, 'Foo');
+    }
+
+
+    /**
+     * @see it('adds new root types via schema extension')
+     */
+    public function testAddsNewRootTypesViaSchemaExtension()
+    {
+        $schema = $this->extendTestSchema('
+            extend schema {
+              mutation: Mutation
+            }
+            type Mutation {
+              doSomething: String
+            }
+        ');
+
+        $mutationType = $schema->getMutationType();
+        self::assertEquals($mutationType->name, 'Mutation');
+    }
+
+    /**
+     * @see it('adds multiple new root types via schema extension')
+     */
+    public function testAddsMultipleNewRootTypesViaSchemaExtension()
+    {
+        $schema           = $this->extendTestSchema('
+            extend schema {
+              mutation: Mutation
+              subscription: Subscription
+            }
+            type Mutation {
+              doSomething: String
+            }
+            type Subscription {
+              hearSomething: String
+            }
+        ');
+        $mutationType     = $schema->getMutationType();
+        $subscriptionType = $schema->getSubscriptionType();
+
+        self::assertEquals('Mutation', $mutationType->name);
+        self::assertEquals('Subscription', $subscriptionType->name);
+    }
+
+    /**
+     * @see it('applies multiple schema extensions')
+     */
+    public function testAppliesMultipleSchemaExtensions()
+    {
+        $schema = $this->extendTestSchema('
+            extend schema {
+              mutation: Mutation
+            }
+            extend schema {
+              subscription: Subscription
+            }
+            type Mutation {
+              doSomething: String
+            }
+            type Subscription {
+              hearSomething: String
+            }
+        ');
+
+        $mutationType     = $schema->getMutationType();
+        $subscriptionType = $schema->getSubscriptionType();
+
+        self::assertEquals('Mutation', $mutationType->name);
+        self::assertEquals('Subscription', $subscriptionType->name);
+    }
+
+    /**
+     * @see it('schema extension AST are available from schema object')
+     */
+    public function testSchemaExtensionASTAreAvailableFromSchemaObject()
+    {
+        $schema = $this->extendTestSchema('
+            extend schema {
+              mutation: Mutation
+            }
+            extend schema {
+              subscription: Subscription
+            }
+            type Mutation {
+              doSomething: String
+            }
+            type Subscription {
+              hearSomething: String
+            }
+        ');
+
+        $ast    = Parser::parse('
+            extend schema @foo
+        ');
+        $schema = SchemaExtender::extend($schema, $ast);
+
+        $nodes = $schema->extensionASTNodes;
+        self::assertEquals(
+            $this->dedent('
+                extend schema {
+                  mutation: Mutation
+                }
+
+                extend schema {
+                  subscription: Subscription
+                }
+
+                extend schema @foo
+            '),
+            implode(
+                PHP_EOL,
+                array_map(static function ($node) {
+                    return Printer::doPrint($node) . PHP_EOL;
+                }, $nodes)
+            )
+        );
+    }
+
+    /**
+     * @see it('does not allow redefining an existing root type')
+     */
+    public function testDoesNotAllowRedefiningAnExistingRootType()
+    {
+        $sdl = '
+            extend schema {
+                query: SomeType
+            }
+
+            type SomeType {
+                seeSomething: String
+            }
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Must provide only one query type in schema.', $error->getMessage());
+        }
+    }
+
+
+    /**
+     * @see it('does not allow defining a root operation type twice')
+     */
+    public function testDoesNotAllowDefiningARootOperationTypeTwice()
+    {
+        $sdl = '
+            extend schema {
+              mutation: Mutation
+            }
+            extend schema {
+              mutation: Mutation
+            }
+            type Mutation {
+              doSomething: String
+            }
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Must provide only one mutation type in schema.', $error->getMessage());
+        }
+    }
+
+    /**
+     * @see it('does not allow defining a root operation type with different types')
+     */
+    public function testDoesNotAllowDefiningARootOperationTypeWithDifferentTypes()
+    {
+        $sdl = '
+            extend schema {
+              mutation: Mutation
+            }
+            extend schema {
+              mutation: SomethingElse
+            }
+            type Mutation {
+              doSomething: String
+            }
+            type SomethingElse {
+              doSomethingElse: String
+            }
+        ';
+
+        try {
+            $this->extendTestSchema($sdl);
+            self::fail();
+        } catch (Error $error) {
+            self::assertEquals('Must provide only one mutation type in schema.', $error->getMessage());
+        }
+    }
+}