[RFC] Add Schema Definition to IDL.

Related GraphQL-js commit: graphql/graphql-js@8379e71

Author: syrusakbary

graphql/language/ast.py

@@ -834,8 +834,80 @@ def __hash__(self):
         return id(self)
 
 
+# Type System Definition
+
 class TypeDefinition(Node):
-    __slots__ = ()
+    pass
+
+
+class TypeSystemDefinition(TypeDefinition):
+    pass
+
+
+class SchemaDefinition(TypeSystemDefinition):
+    __slots__ = ('loc', 'operation_types',)
+    _fields = ('operation_types',)
+
+    def __init__(self, operation_types, loc=None):
+        self.operation_types = operation_types
+        self.loc = loc
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, SchemaDefinition) and
+                self.operation_types == other.operation_types
+            )
+        )
+
+    def __repr__(self):
+        return ('SchemaDefinition('
+                'operation_types={self.operation_types!r}'
+                ')').format(self=self)
+
+    def __copy__(self):
+        return type(self)(
+            self.operation_types,
+            self.loc
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
+class OperationTypeDefinition(Node):
+    __slots__ = ('loc', 'operation', 'type',)
+    _fields = ('operation', 'type',)
+
+    def __init__(self, operation, type, loc=None):
+        self.operation = operation
+        self.type = type
+        self.loc = loc
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, OperationTypeDefinition) and
+                self.operation == other.operation and
+                self.type == other.type
+            )
+        )
+
+    def __repr__(self):
+        return ('OperationTypeDefinition('
+                'operation={self.operation!r}'
+                ', type={self.type!r}'
+                ')').format(self=self)
+
+    def __copy__(self):
+        return type(self)(
+            self.operation,
+            self.type,
+            self.loc
+        )
+
+    def __hash__(self):
+        return id(self)
 
 
 class ObjectTypeDefinition(TypeDefinition):
@@ -1166,7 +1238,7 @@ def __hash__(self):
         return id(self)
 
 
-class TypeExtensionDefinition(TypeDefinition):
+class TypeExtensionDefinition(TypeSystemDefinition):
     __slots__ = ('loc', 'definition',)
     _fields = ('definition',)
 
@@ -1198,7 +1270,7 @@ def __hash__(self):
         return id(self)
 
 
-class DirectiveDefinition(TypeDefinition):
+class DirectiveDefinition(TypeSystemDefinition):
     __slots__ = ('loc', 'name', 'arguments', 'locations')
     _fields = ('name', 'locations')
 

graphql/language/parser.py

@@ -209,7 +209,7 @@ def parse_definition(parser):
             return parse_operation_definition(parser)
         elif name == 'fragment':
             return parse_fragment_definition(parser)
-        elif name in ('scalar', 'type', 'interface', 'union', 'enum', 'input', 'extend', 'directive'):
+        elif name in ('schema', 'scalar', 'type', 'interface', 'union', 'enum', 'input', 'extend', 'directive'):
             return parse_type_system_definition(parser)
 
     raise unexpected(parser)
@@ -228,8 +228,7 @@ def parse_operation_definition(parser):
             loc=loc(parser, start)
         )
 
-    operation_token = expect(parser, TokenKind.NAME)
-    operation = operation_token.value
+    operation = parse_operation_type(parser)
 
     name = None
     if peek(parser, TokenKind.NAME):
@@ -245,6 +244,19 @@ def parse_operation_definition(parser):
     )
 
 
+def parse_operation_type(parser):
+    operation_token = expect(parser, TokenKind.NAME)
+    operation = operation_token.value
+    if operation == 'query':
+        return 'query'
+    elif operation == 'mutation':
+        return 'mutation'
+    elif operation == 'subscription':
+        return 'subscription'
+
+    raise unexpected(parser, operation_token)
+
+
 def parse_variable_definitions(parser):
     if peek(parser, TokenKind.PAREN_L):
         return many(
@@ -512,7 +524,10 @@ def parse_type_system_definition(parser):
 
     name = parser.token.value
 
-    if name == 'scalar':
+    if name == 'schema':
+        return parse_schema_definition(parser)
+
+    elif name == 'scalar':
         return parse_scalar_type_definition(parser)
 
     elif name == 'type':
@@ -539,6 +554,34 @@ def parse_type_system_definition(parser):
     raise unexpected(parser)
 
 
+def parse_schema_definition(parser):
+    start = parser.token.start
+    expect_keyword(parser, 'schema')
+    operation_types = many(
+        parser,
+        TokenKind.BRACE_L,
+        parse_operation_type_definition,
+        TokenKind.BRACE_R
+    )
+
+    return ast.SchemaDefinition(
+        operation_types=operation_types,
+        loc=loc(parser, start)
+    )
+
+
+def parse_operation_type_definition(parser):
+    start = parser.token.start
+    operation = parse_operation_type(parser)
+    expect(parser, TokenKind.COLON)
+
+    return ast.OperationTypeDefinition(
+        operation=operation,
+        type=parse_named_type(parser),
+        loc=loc(parser, start)
+    )
+
+
 def parse_scalar_type_definition(parser):
     start = parser.token.start
     expect_keyword(parser, 'scalar')

graphql/language/printer.py

@@ -111,6 +111,12 @@ def leave_NonNullType(self, node, *args):
 
     # Type Definitions:
 
+    def leave_SchemaDefinition(self, node, *args):
+        return 'schema ' + block(node.operation_types)
+
+    def leave_OperationTypeDefinition(self, node, *args):
+        return '{}: {}'.format(node.operation, node.type)
+
     def leave_ScalarTypeDefinition(self, node, *args):
         return 'scalar ' + node.name
 

graphql/language/tests/fixtures.py

@@ -67,6 +67,11 @@
 # LICENSE file in the root directory of this source tree. An additional grant
 # of patent rights can be found in the PATENTS file in the same directory.
 
+schema {
+  query: QueryType
+  mutation: MutationType
+}
+
 type Foo implements Bar {
   one: Type
   two(argument: InputType!): Type

graphql/language/tests/test_schema_printer.py

@@ -36,7 +36,12 @@ def test_prints_kitchen_sink():
     ast = parse(SCHEMA_KITCHEN_SINK)
     printed = print_ast(ast)
 
-    expected = '''type Foo implements Bar {
+    expected = '''schema {
+  query: QueryType
+  mutation: MutationType
+}
+
+type Foo implements Bar {
   one: Type
   two(argument: InputType!): Type
   three(argument: InputType, other: String): Int

graphql/language/visitor_meta.py

@@ -30,16 +30,21 @@
     ast.ListType: ('type',),
     ast.NonNullType: ('type',),
 
+    ast.SchemaDefinition: ('operation_types',),
+    ast.OperationTypeDefinition: ('type',),
+
+    ast.ScalarTypeDefinition: ('name',),
     ast.ObjectTypeDefinition: ('name', 'interfaces', 'fields'),
     ast.FieldDefinition: ('name', 'arguments', 'type'),
     ast.InputValueDefinition: ('name', 'type', 'default_value'),
     ast.InterfaceTypeDefinition: ('name', 'fields'),
     ast.UnionTypeDefinition: ('name', 'types'),
-    ast.ScalarTypeDefinition: ('name',),
     ast.EnumTypeDefinition: ('name', 'values'),
     ast.EnumValueDefinition: ('name',),
     ast.InputObjectTypeDefinition: ('name', 'fields'),
+
     ast.TypeExtensionDefinition: ('definition',),
+
     ast.DirectiveDefinition: ('name', 'arguments', 'locations'),
 }
 

graphql/utils/build_ast_schema.py

@@ -34,39 +34,35 @@ def _false(*_): return False
 def _none(*_): return None
 
 
-def build_ast_schema(document, query_type_name, mutation_type_name=None, subscription_type_name=None):
+def build_ast_schema(document):
     assert isinstance(document, ast.Document), 'must pass in Document ast.'
-    assert query_type_name, 'must pass in query type'
+
+    schema_def = None
 
     type_asts = (
+        ast.ScalarTypeDefinition,
         ast.ObjectTypeDefinition,
         ast.InterfaceTypeDefinition,
         ast.EnumTypeDefinition,
         ast.UnionTypeDefinition,
-        ast.ScalarTypeDefinition,
         ast.InputObjectTypeDefinition,
     )
 
     type_defs = []
     directive_defs = []
 
     for d in document.definitions:
+        if isinstance(d, ast.SchemaDefinition):
+            if schema_def:
+                raise Exception('Must provide only one schema definition.')
+            schema_def = d
         if isinstance(d, type_asts):
             type_defs.append(d)
         elif isinstance(d, ast.DirectiveDefinition):
             directive_defs.append(d)
 
     ast_map = {d.name.value: d for d in type_defs}
 
-    if query_type_name not in ast_map:
-        raise Exception('Specified query type {} not found in document.'.format(query_type_name))
-
-    if mutation_type_name and mutation_type_name not in ast_map:
-        raise Exception('Specified mutation type {} not found in document.'.format(mutation_type_name))
-
-    if subscription_type_name and subscription_type_name not in ast_map:
-        raise Exception('Specified subscription type {} not found in document.'.format(subscription_type_name))
-
     inner_type_map = OrderedDict([
         ('String', GraphQLString),
         ('Int', GraphQLInt),
@@ -81,11 +77,11 @@ def produce_type_def(type_ast):
             return _build_wrapped_type(inner_type_map[type_name], type_ast)
 
         if type_name not in ast_map:
-            raise Exception('Type {} not found in document.'.format(type_name))
+            raise Exception('Type "{}" not found in document.'.format(type_name))
 
         inner_type_def = make_schema_def(ast_map[type_name])
         if not inner_type_def:
-            raise Exception('Nothing constructed for {}.'.format(type_name))
+            raise Exception('Nothing constructed for "{}".'.format(type_name))
 
         inner_type_map[type_name] = inner_type_def
         return _build_wrapped_type(inner_type_def, type_ast)
@@ -172,7 +168,7 @@ def make_schema_def(definition):
 
         handler = _schema_def_handlers.get(type(definition))
         if not handler:
-            raise Exception('{} not supported.'.format(type(definition).__name__))
+            raise Exception('Type kind "{}" not supported.'.format(type(definition).__name__))
 
         return handler(definition)
 
@@ -186,6 +182,33 @@ def get_directive(directive_ast):
     for definition in type_defs:
         produce_type_def(definition)
 
+    if not schema_def:
+        raise Exception('Must provide a schema definition.')
+
+    query_type_name = None
+    mutation_type_name = None
+    subscription_type_name = None
+    for operation_type in schema_def.operation_types:
+        type_name = operation_type.type.name.value
+        if operation_type.operation == 'query':
+            query_type_name = type_name
+        elif operation_type.operation == 'mutation':
+            mutation_type_name = type_name
+        elif operation_type.operation == 'subscription':
+            subscription_type_name = type_name
+
+    if not query_type_name:
+        raise Exception('Must provide schema definition with query type.')
+
+    if query_type_name not in ast_map:
+        raise Exception('Specified query type "{}" not found in document.'.format(query_type_name))
+
+    if mutation_type_name and mutation_type_name not in ast_map:
+        raise Exception('Specified mutation type "{}" not found in document.'.format(mutation_type_name))
+
+    if subscription_type_name and subscription_type_name not in ast_map:
+        raise Exception('Specified subscription type "{}" not found in document.'.format(subscription_type_name))
+
     schema_kwargs = {'query': produce_type_def(ast_map[query_type_name])}
 
     if mutation_type_name:

graphql/utils/schema_printer.py

@@ -34,6 +34,8 @@ def _is_builtin_scalar(typename):
 
 def _print_filtered_schema(schema, directive_filter, type_filter):
     return '\n\n'.join([
+        _print_schema_definition(schema)
+    ] + [
         _print_directive(directive)
         for directive in schema.get_directives()
         if directive_filter(directive.name)
@@ -44,6 +46,24 @@ def _print_filtered_schema(schema, directive_filter, type_filter):
     ]) + '\n'
 
 
+def _print_schema_definition(schema):
+    operation_types = []
+
+    query_type = schema.get_query_type()
+    if query_type:
+        operation_types.append('  query: {}'.format(query_type))
+
+    mutation_type = schema.get_mutation_type()
+    if mutation_type:
+        operation_types.append('  mutation: {}'.format(mutation_type))
+
+    subscription_type = schema.get_subscription_type()
+    if subscription_type:
+        operation_types.append('  subscription: {}'.format(subscription_type))
+
+    return 'schema {{\n{}\n}}'.format('\n'.join(operation_types))
+
+
 def _print_type(type):
     if isinstance(type, GraphQLScalarType):
         return _print_scalar(type)