graphql 2.0.30 → 2.3.6

data/lib/graphql/language/document_from_schema_definition.rb

@@ -14,7 +14,7 @@ module GraphQL
     # @param include_built_in_directives [Boolean] Whether or not to include built in directives in the AST
     class DocumentFromSchemaDefinition
       def initialize(
-        schema, context: nil, only: nil, except: nil, include_introspection_types: false,
+        schema, context: nil, include_introspection_types: false,
         include_built_in_directives: false, include_built_in_scalars: false, always_include_schema: false
       )
         @schema = schema
@@ -24,23 +24,13 @@ module GraphQL
         @include_built_in_directives = include_built_in_directives
         @include_one_of = false
 
-        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
+        schema_context = schema.context_class.new(query: nil, schema: schema, values: context)
 
-        @warden = if only || except
-          filter = GraphQL::Filter
-            .new(only: only, except: except)
-            .merge(only: @schema.method(:visible?))
-          GraphQL::Schema::Warden.new(
-              filter,
-              schema: @schema,
-              context: schema_context,
-            )
-        else
-          @schema.warden_class.new(
-            schema: @schema,
-            context: schema_context,
-          )
-        end
+
+        @warden = @schema.warden_class.new(
+          schema: @schema,
+          context: schema_context,
+        )
 
         schema_context.warden = @warden
       end
@@ -52,24 +42,30 @@ module GraphQL
       end
 
       def build_schema_node
-        schema_options = {
-          # `@schema.directives` is covered by `build_definition_nodes`
-          directives: definition_directives(@schema, :schema_directives),
-        }
         if !schema_respects_root_name_conventions?(@schema)
-          schema_options.merge!({
+          GraphQL::Language::Nodes::SchemaDefinition.new(
             query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
             mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
             subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
-          })
+            directives: definition_directives(@schema, :schema_directives)
+          )
+        else
+          # A plain `schema ...` _must_ include root type definitions.
+          # If the only difference is directives, then you have to use `extend schema`
+          GraphQL::Language::Nodes::SchemaExtension.new(directives: definition_directives(@schema, :schema_directives))
         end
-        GraphQL::Language::Nodes::SchemaDefinition.new(schema_options)
       end
 
       def build_object_type_node(object_type)
+        ints = warden.interfaces(object_type)
+        if ints.any?
+          ints.sort_by!(&:graphql_name)
+          ints.map! { |iface| build_type_name_node(iface) }
+        end
+
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.graphql_name,
-          interfaces: warden.interfaces(object_type).sort_by(&:graphql_name).map { |iface| build_type_name_node(iface) },
+          interfaces: ints,
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
           directives: directives(object_type),
@@ -190,7 +186,8 @@ module GraphQL
             of_type: build_type_name_node(type.of_type)
           )
         else
-          GraphQL::Language::Nodes::TypeName.new(name: type.graphql_name)
+          @cached_type_name_nodes ||= {}
+          @cached_type_name_nodes[type.graphql_name] ||= GraphQL::Language::Nodes::TypeName.new(name: type.graphql_name)
         end
       end
 
@@ -247,9 +244,13 @@ module GraphQL
       end
 
       def build_argument_nodes(arguments)
-        arguments
-          .map { |arg| build_argument_node(arg) }
-          .sort_by(&:name)
+        if arguments.any?
+          nodes = arguments.map { |arg| build_argument_node(arg) }
+          nodes.sort_by!(&:name)
+          nodes
+        else
+          arguments
+        end
       end
 
       def build_directive_nodes(directives)
@@ -263,16 +264,15 @@ module GraphQL
         if !include_built_in_directives
           dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
         end
-        dir_nodes = build_directive_nodes(dirs_to_build)
-
-        type_nodes = build_type_definition_nodes(warden.reachable_types)
+        definitions = build_directive_nodes(dirs_to_build)
 
+        type_nodes = build_type_definition_nodes(warden.reachable_types + schema.extra_types)
         if @include_one_of
           # This may have been set to true when iterating over all types
-          dir_nodes.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
+          definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
         end
 
-        definitions = [*dir_nodes, *type_nodes]
+        definitions.concat(type_nodes)
         if include_schema_node?
           definitions.unshift(build_schema_node)
         end
@@ -295,9 +295,9 @@ module GraphQL
       end
 
       def build_field_nodes(fields)
-        fields
-          .map { |field| build_field_node(field) }
-          .sort_by(&:name)
+        f_nodes = fields.map { |field| build_field_node(field) }
+        f_nodes.sort_by!(&:name)
+        f_nodes
       end
 
       private
@@ -320,7 +320,7 @@ module GraphQL
 
       def definition_directives(member, directives_method)
         dirs = if !member.respond_to?(directives_method) || member.directives.empty?
-          []
+          EmptyObjects::EMPTY_ARRAY
         else
           member.public_send(directives_method).map do |dir|
             args = []