RFC: SchemaExtension

src/index.js

@@ -245,14 +245,16 @@ export type {
   EnumTypeDefinitionNode,
   EnumValueDefinitionNode,
   InputObjectTypeDefinitionNode,
+  DirectiveDefinitionNode,
+  TypeSystemExtensionNode,
+  SchemaExtensionNode,
   TypeExtensionNode,
   ScalarTypeExtensionNode,
   ObjectTypeExtensionNode,
   InterfaceTypeExtensionNode,
   UnionTypeExtensionNode,
   EnumTypeExtensionNode,
   InputObjectTypeExtensionNode,
-  DirectiveDefinitionNode,
   KindEnum,
   TokenKindEnum,
   DirectiveLocationEnum,

src/language/__tests__/schema-kitchen-sink.graphql

@@ -123,3 +123,9 @@ directive @include2(if: Boolean!) on
   | FIELD
   | FRAGMENT_SPREAD
   | INLINE_FRAGMENT
+
+extend schema @onSchema
+
+extend schema @onSchema {
+  subscription: SubscriptionType
+}

src/language/__tests__/schema-parser-test.js

@@ -263,6 +263,66 @@ extend type Hello {
     );
   });
 
+  it('Schema extension', () => {
+    const body = `
+      extend schema {
+        mutation: Mutation
+      }`;
+    const doc = parse(body);
+    const expected = {
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'SchemaExtension',
+          directives: [],
+          operationTypes: [
+            {
+              kind: 'OperationTypeDefinition',
+              operation: 'mutation',
+              type: typeNode('Mutation', { start: 41, end: 49 }),
+              loc: { start: 31, end: 49 },
+            },
+          ],
+          loc: { start: 7, end: 57 },
+        },
+      ],
+      loc: { start: 0, end: 57 },
+    };
+    expect(printJson(doc)).to.equal(printJson(expected));
+  });
+
+  it('Schema extension with only directives', () => {
+    const body = 'extend schema @directive';
+    const doc = parse(body);
+    const expected = {
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'SchemaExtension',
+          directives: [
+            {
+              kind: 'Directive',
+              name: nameNode('directive', { start: 15, end: 24 }),
+              arguments: [],
+              loc: { start: 14, end: 24 },
+            },
+          ],
+          operationTypes: [],
+          loc: { start: 0, end: 24 },
+        },
+      ],
+      loc: { start: 0, end: 24 },
+    };
+    expect(printJson(doc)).to.equal(printJson(expected));
+  });
+
+  it('Schema extension without anything throws', () => {
+    expectSyntaxError('extend schema', 'Unexpected <EOF>', {
+      line: 1,
+      column: 14,
+    });
+  });
+
   it('Simple non-null type', () => {
     const body = `
 type Hello {

src/language/__tests__/schema-printer-test.js

@@ -161,6 +161,12 @@ describe('Printer: SDL document', () => {
       directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
       directive @include2(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+      extend schema @onSchema
+
+      extend schema @onSchema {
+        subscription: SubscriptionType
+      }
     `);
   });
 });

src/language/ast.js

@@ -124,13 +124,14 @@ export type ASTNode =
   | EnumTypeDefinitionNode
   | EnumValueDefinitionNode
   | InputObjectTypeDefinitionNode
+  | DirectiveDefinitionNode
+  | SchemaExtensionNode
   | ScalarTypeExtensionNode
   | ObjectTypeExtensionNode
   | InterfaceTypeExtensionNode
   | UnionTypeExtensionNode
   | EnumTypeExtensionNode
-  | InputObjectTypeExtensionNode
-  | DirectiveDefinitionNode;
+  | InputObjectTypeExtensionNode;
 
 /**
  * Utility type listing all nodes indexed by their kind.
@@ -171,13 +172,14 @@ export type ASTKindToNode = {
   EnumTypeDefinition: EnumTypeDefinitionNode,
   EnumValueDefinition: EnumValueDefinitionNode,
   InputObjectTypeDefinition: InputObjectTypeDefinitionNode,
+  DirectiveDefinition: DirectiveDefinitionNode,
+  SchemaExtension: SchemaExtensionNode,
   ScalarTypeExtension: ScalarTypeExtensionNode,
   ObjectTypeExtension: ObjectTypeExtensionNode,
   InterfaceTypeExtension: InterfaceTypeExtensionNode,
   UnionTypeExtension: UnionTypeExtensionNode,
   EnumTypeExtension: EnumTypeExtensionNode,
   InputObjectTypeExtension: InputObjectTypeExtensionNode,
-  DirectiveDefinition: DirectiveDefinitionNode,
 };
 
 // Name
@@ -198,7 +200,8 @@ export type DocumentNode = {
 
 export type DefinitionNode =
   | ExecutableDefinitionNode
-  | TypeSystemDefinitionNode; // experimental non-spec addition.
+  | TypeSystemDefinitionNode
+  | TypeSystemExtensionNode;
 
 export type ExecutableDefinitionNode =
   | OperationDefinitionNode
@@ -388,13 +391,12 @@ export type NonNullTypeNode = {
 export type TypeSystemDefinitionNode =
   | SchemaDefinitionNode
   | TypeDefinitionNode
-  | TypeExtensionNode
   | DirectiveDefinitionNode;
 
 export type SchemaDefinitionNode = {
   +kind: 'SchemaDefinition',
   +loc?: Location,
-  +directives: $ReadOnlyArray<DirectiveNode>,
+  +directives?: $ReadOnlyArray<DirectiveNode>,
   +operationTypes: $ReadOnlyArray<OperationTypeDefinitionNode>,
 };
 
@@ -497,6 +499,28 @@ export type InputObjectTypeDefinitionNode = {
   +fields?: $ReadOnlyArray<InputValueDefinitionNode>,
 };
 
+// Directive Definitions
+
+export type DirectiveDefinitionNode = {
+  +kind: 'DirectiveDefinition',
+  +loc?: Location,
+  +description?: StringValueNode,
+  +name: NameNode,
+  +arguments?: $ReadOnlyArray<InputValueDefinitionNode>,
+  +locations: $ReadOnlyArray<NameNode>,
+};
+
+// Type System Extensions
+
+export type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
+
+export type SchemaExtensionNode = {
+  +kind: 'SchemaExtension',
+  +loc?: Location,
+  +directives?: $ReadOnlyArray<DirectiveNode>,
+  +operationTypes?: $ReadOnlyArray<OperationTypeDefinitionNode>,
+};
+
 // Type Extensions
 
 export type TypeExtensionNode =
@@ -554,14 +578,3 @@ export type InputObjectTypeExtensionNode = {
   +directives?: $ReadOnlyArray<DirectiveNode>,
   +fields?: $ReadOnlyArray<InputValueDefinitionNode>,
 };
-
-// Directive Definitions
-
-export type DirectiveDefinitionNode = {
-  +kind: 'DirectiveDefinition',
-  +loc?: Location,
-  +description?: StringValueNode,
-  +name: NameNode,
-  +arguments?: $ReadOnlyArray<InputValueDefinitionNode>,
-  +locations: $ReadOnlyArray<NameNode>,
-};

src/language/index.js

@@ -76,14 +76,16 @@ export type {
   EnumTypeDefinitionNode,
   EnumValueDefinitionNode,
   InputObjectTypeDefinitionNode,
+  DirectiveDefinitionNode,
+  TypeSystemExtensionNode,
+  SchemaExtensionNode,
   TypeExtensionNode,
   ScalarTypeExtensionNode,
   ObjectTypeExtensionNode,
   InterfaceTypeExtensionNode,
   UnionTypeExtensionNode,
   EnumTypeExtensionNode,
   InputObjectTypeExtensionNode,
-  DirectiveDefinitionNode,
 } from './ast';
 
 export { DirectiveLocation } from './directiveLocation';

src/language/kinds.js

@@ -62,16 +62,19 @@ export const Kind = Object.freeze({
   ENUM_VALUE_DEFINITION: 'EnumValueDefinition',
   INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',
 
+  // Directive Definitions
+  DIRECTIVE_DEFINITION: 'DirectiveDefinition',
+
+  // Type System Extensions
+  SCHEMA_EXTENSION: 'SchemaExtension',
+
   // Type Extensions
   SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',
   OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',
   INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',
   UNION_TYPE_EXTENSION: 'UnionTypeExtension',
   ENUM_TYPE_EXTENSION: 'EnumTypeExtension',
   INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension',
-
-  // Directive Definitions
-  DIRECTIVE_DEFINITION: 'DirectiveDefinition',
 });
 
 /**

src/language/parser.js

@@ -52,14 +52,15 @@ import type {
   EnumTypeDefinitionNode,
   EnumValueDefinitionNode,
   InputObjectTypeDefinitionNode,
-  TypeExtensionNode,
+  DirectiveDefinitionNode,
+  TypeSystemExtensionNode,
+  SchemaExtensionNode,
   ScalarTypeExtensionNode,
   ObjectTypeExtensionNode,
   InterfaceTypeExtensionNode,
   UnionTypeExtensionNode,
   EnumTypeExtensionNode,
   InputObjectTypeExtensionNode,
-  DirectiveDefinitionNode,
 } from './ast';
 
 import { Kind } from './kinds';
@@ -211,6 +212,7 @@ function parseDocument(lexer: Lexer<*>): DocumentNode {
  * Definition :
  *   - ExecutableDefinition
  *   - TypeSystemDefinition
+ *   - TypeSystemExtension
  */
 function parseDefinition(lexer: Lexer<*>): DefinitionNode {
   if (peek(lexer, TokenKind.NAME)) {
@@ -227,15 +229,14 @@ function parseDefinition(lexer: Lexer<*>): DefinitionNode {
       case 'union':
       case 'enum':
       case 'input':
-      case 'extend':
       case 'directive':
-        // Note: The schema definition language is an experimental addition.
         return parseTypeSystemDefinition(lexer);
+      case 'extend':
+        return parseTypeSystemExtension(lexer);
     }
   } else if (peek(lexer, TokenKind.BRACE_L)) {
     return parseExecutableDefinition(lexer);
   } else if (peekDescription(lexer)) {
-    // Note: The schema definition language is an experimental addition.
     return parseTypeSystemDefinition(lexer);
   }
 
@@ -753,7 +754,6 @@ export function parseNamedType(lexer: Lexer<*>): NamedTypeNode {
  * TypeSystemDefinition :
  *   - SchemaDefinition
  *   - TypeDefinition
- *   - TypeExtension
  *   - DirectiveDefinition
  *
  * TypeDefinition :
@@ -784,8 +784,6 @@ function parseTypeSystemDefinition(lexer: Lexer<*>): TypeSystemDefinitionNode {
         return parseEnumTypeDefinition(lexer);
       case 'input':
         return parseInputObjectTypeDefinition(lexer);
-      case 'extend':
-        return parseTypeExtension(lexer);
       case 'directive':
         return parseDirectiveDefinition(lexer);
     }
@@ -1141,6 +1139,10 @@ function parseInputFieldsDefinition(
 }
 
 /**
+ * TypeSystemExtension :
+ *   - SchemaExtension
+ *   - TypeExtension
+ *
  * TypeExtension :
  *   - ScalarTypeExtension
  *   - ObjectTypeExtension
@@ -1149,11 +1151,13 @@ function parseInputFieldsDefinition(
  *   - EnumTypeExtension
  *   - InputObjectTypeDefinition
  */
-function parseTypeExtension(lexer: Lexer<*>): TypeExtensionNode {
+function parseTypeSystemExtension(lexer: Lexer<*>): TypeSystemExtensionNode {
   const keywordToken = lexer.lookahead();
 
   if (keywordToken.kind === TokenKind.NAME) {
     switch (keywordToken.value) {
+      case 'schema':
+        return parseSchemaExtension(lexer);
       case 'scalar':
         return parseScalarTypeExtension(lexer);
       case 'type':
@@ -1172,6 +1176,35 @@ function parseTypeExtension(lexer: Lexer<*>): TypeExtensionNode {
   throw unexpected(lexer, keywordToken);
 }
 
+/**
+ * SchemaExtension :
+ *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+ *  - extend schema Directives[Const]
+ */
+function parseSchemaExtension(lexer: Lexer<*>): SchemaExtensionNode {
+  const start = lexer.token;
+  expectKeyword(lexer, 'extend');
+  expectKeyword(lexer, 'schema');
+  const directives = parseDirectives(lexer, true);
+  const operationTypes = peek(lexer, TokenKind.BRACE_L)
+    ? many(
+        lexer,
+        TokenKind.BRACE_L,
+        parseOperationTypeDefinition,
+        TokenKind.BRACE_R,
+      )
+    : [];
+  if (directives.length === 0 && operationTypes.length === 0) {
+    throw unexpected(lexer);
+  }
+  return {
+    kind: Kind.SCHEMA_EXTENSION,
+    directives,
+    operationTypes,
+    loc: loc(lexer, start),
+  };
+}
+
 /**
  * ScalarTypeExtension :
  *   - extend scalar Name Directives[Const]