graphql 1.8.7 → 1.9.0

data/lib/graphql/internal_representation/rewrite.rb

@@ -13,127 +13,29 @@ module GraphQL
     #
     # The rewritten query tree serves as the basis for the `FieldsWillMerge` validation.
     #
-    class Rewrite
+    module Rewrite
       include GraphQL::Language
 
       NO_DIRECTIVES = [].freeze
 
       # @return InternalRepresentation::Document
-      attr_reader :document
+      attr_reader :rewrite_document
 
-      def initialize
-        @document = InternalRepresentation::Document.new
-      end
-
-      # @return [Hash<String, Node>] Roots of this query
-      def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
-        document.operation_definitions
-      end
-
-      def validate(context)
-        visitor = context.visitor
-        query = context.query
+      def initialize(*)
+        super
+        @query = context.query
+        @rewrite_document = InternalRepresentation::Document.new
         # Hash<Nodes::FragmentSpread => Set<InternalRepresentation::Node>>
         # A record of fragment spreads and the irep nodes that used them
-        spread_parents = Hash.new { |h, k| h[k] = Set.new }
+        @rewrite_spread_parents = Hash.new { |h, k| h[k] = Set.new }
         # Hash<Nodes::FragmentSpread => Scope>
-        spread_scopes = {}
+        @rewrite_spread_scopes = {}
         # Array<Set<InternalRepresentation::Node>>
         # The current point of the irep_tree during visitation
-        nodes_stack = []
+        @rewrite_nodes_stack = []
         # Array<Scope>
-        scopes_stack = []
-
-        skip_nodes = Set.new
-
-        visit_op = VisitDefinition.new(context, @document.operation_definitions, nodes_stack, scopes_stack)
-        visitor[Nodes::OperationDefinition].enter << visit_op.method(:enter)
-        visitor[Nodes::OperationDefinition].leave << visit_op.method(:leave)
-
-        visit_frag = VisitDefinition.new(context, @document.fragment_definitions, nodes_stack, scopes_stack)
-        visitor[Nodes::FragmentDefinition].enter << visit_frag.method(:enter)
-        visitor[Nodes::FragmentDefinition].leave << visit_frag.method(:leave)
-
-        visitor[Nodes::InlineFragment].enter << ->(ast_node, ast_parent) {
-          # Inline fragments provide two things to the rewritten tree:
-          # - They _may_ narrow the scope by their type condition
-          # - They _may_ apply their directives to their children
-          if skip?(ast_node, query)
-            skip_nodes.add(ast_node)
-          end
-
-          if skip_nodes.none?
-            scopes_stack.push(scopes_stack.last.enter(context.type_definition))
-          end
-        }
-
-        visitor[Nodes::InlineFragment].leave << ->(ast_node, ast_parent) {
-          if skip_nodes.none?
-            scopes_stack.pop
-          end
-
-          if skip_nodes.include?(ast_node)
-            skip_nodes.delete(ast_node)
-          end
-        }
-
-        visitor[Nodes::Field].enter << ->(ast_node, ast_parent) {
-          if skip?(ast_node, query)
-            skip_nodes.add(ast_node)
-          end
-
-          if skip_nodes.none?
-            node_name = ast_node.alias || ast_node.name
-            parent_nodes = nodes_stack.last
-            next_nodes = []
-
-            field_defn = context.field_definition
-            if field_defn.nil?
-              # It's a non-existent field
-              new_scope = nil
-            else
-              field_return_type = field_defn.type
-              scopes_stack.last.each do |scope_type|
-                parent_nodes.each do |parent_node|
-                  node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
-                    parent: parent_node,
-                    name: node_name,
-                    owner_type: scope_type,
-                    query: query,
-                    return_type: field_return_type,
-                  )
-                  node.ast_nodes << ast_node
-                  node.definitions << field_defn
-                  next_nodes << node
-                end
-              end
-              new_scope = Scope.new(query, field_return_type.unwrap)
-            end
-
-            nodes_stack.push(next_nodes)
-            scopes_stack.push(new_scope)
-          end
-        }
-
-        visitor[Nodes::Field].leave << ->(ast_node, ast_parent) {
-          if skip_nodes.none?
-            nodes_stack.pop
-            scopes_stack.pop
-          end
-
-          if skip_nodes.include?(ast_node)
-            skip_nodes.delete(ast_node)
-          end
-        }
-
-        visitor[Nodes::FragmentSpread].enter << ->(ast_node, ast_parent) {
-          if skip_nodes.none? && !skip?(ast_node, query)
-            # Register the irep nodes that depend on this AST node:
-            spread_parents[ast_node].merge(nodes_stack.last)
-            spread_scopes[ast_node] = scopes_stack.last
-          end
-        }
+        @rewrite_scopes_stack = []
+        @rewrite_skip_nodes = Set.new
 
         # Resolve fragment spreads.
         # Fragment definitions got their own irep trees during visitation.
@@ -142,12 +44,12 @@ module GraphQL
         # can be shared between its usages.
         context.on_dependency_resolve do |defn_ast_node, spread_ast_nodes, frag_ast_node|
           frag_name = frag_ast_node.name
-          fragment_node = @document.fragment_definitions[frag_name]
+          fragment_node = @rewrite_document.fragment_definitions[frag_name]
 
           if fragment_node
             spread_ast_nodes.each do |spread_ast_node|
-              parent_nodes = spread_parents[spread_ast_node]
-              parent_scope = spread_scopes[spread_ast_node]
+              parent_nodes = @rewrite_spread_parents[spread_ast_node]
+              parent_scope = @rewrite_spread_scopes[spread_ast_node]
               parent_nodes.each do |parent_node|
                 parent_node.deep_merge_node(fragment_node, scope: parent_scope, merge_self: false)
               end
@@ -156,43 +58,126 @@ module GraphQL
         end
       end
 
-      def skip?(ast_node, query)
-        dir = ast_node.directives
-        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
+      # @return [Hash<String, Node>] Roots of this query
+      def operations
+        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        @document.operation_definitions
+      end
+
+      def on_operation_definition(ast_node, parent)
+        push_root_node(ast_node, @rewrite_document.operation_definitions) { super }
+      end
+
+      def on_fragment_definition(ast_node, parent)
+        push_root_node(ast_node, @rewrite_document.fragment_definitions) { super }
+      end
+
+      def push_root_node(ast_node, definitions)
+        # Either QueryType or the fragment type condition
+        owner_type = context.type_definition
+        defn_name = ast_node.name
+
+        node = Node.new(
+          parent: nil,
+          name: defn_name,
+          owner_type: owner_type,
+          query: @query,
+          ast_nodes: [ast_node],
+          return_type: owner_type,
+        )
+
+        definitions[defn_name] = node
+        @rewrite_scopes_stack.push(Scope.new(@query, owner_type))
+        @rewrite_nodes_stack.push([node])
+        yield
+        @rewrite_nodes_stack.pop
+        @rewrite_scopes_stack.pop
+      end
+
+      def on_inline_fragment(node, parent)
+        # Inline fragments provide two things to the rewritten tree:
+        # - They _may_ narrow the scope by their type condition
+        # - They _may_ apply their directives to their children
+        if skip?(node)
+          @rewrite_skip_nodes.add(node)
+        end
+
+        if @rewrite_skip_nodes.empty?
+          @rewrite_scopes_stack.push(@rewrite_scopes_stack.last.enter(context.type_definition))
+        end
+
+        super
+
+        if @rewrite_skip_nodes.empty?
+          @rewrite_scopes_stack.pop
+        end
+
+        if @rewrite_skip_nodes.include?(node)
+          @rewrite_skip_nodes.delete(node)
+        end
       end
 
-      class VisitDefinition
-        def initialize(context, definitions, nodes_stack, scopes_stack)
-          @context = context
-          @query = context.query
-          @definitions = definitions
-          @nodes_stack = nodes_stack
-          @scopes_stack = scopes_stack
+      def on_field(ast_node, ast_parent)
+        if skip?(ast_node)
+          @rewrite_skip_nodes.add(ast_node)
+        end
+
+        if @rewrite_skip_nodes.empty?
+          node_name = ast_node.alias || ast_node.name
+          parent_nodes = @rewrite_nodes_stack.last
+          next_nodes = []
+
+          field_defn = context.field_definition
+          if field_defn.nil?
+            # It's a non-existent field
+            new_scope = nil
+          else
+            field_return_type = field_defn.type
+            @rewrite_scopes_stack.last.each do |scope_type|
+              parent_nodes.each do |parent_node|
+                node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
+                  parent: parent_node,
+                  name: node_name,
+                  owner_type: scope_type,
+                  query: @query,
+                  return_type: field_return_type,
+                )
+                node.ast_nodes << ast_node
+                node.definitions << field_defn
+                next_nodes << node
+              end
+            end
+            new_scope = Scope.new(@query, field_return_type.unwrap)
+          end
+
+          @rewrite_nodes_stack.push(next_nodes)
+          @rewrite_scopes_stack.push(new_scope)
+        end
+
+        super
+
+        if @rewrite_skip_nodes.empty?
+          @rewrite_nodes_stack.pop
+          @rewrite_scopes_stack.pop
         end
 
-        def enter(ast_node, ast_parent)
-          # Either QueryType or the fragment type condition
-          owner_type = @context.type_definition && @context.type_definition.unwrap
-          defn_name = ast_node.name
-
-          node = Node.new(
-            parent: nil,
-            name: defn_name,
-            owner_type: owner_type,
-            query: @query,
-            ast_nodes: [ast_node],
-            return_type: @context.type_definition,
-          )
-
-          @definitions[defn_name] = node
-          @scopes_stack.push(Scope.new(@query, owner_type))
-          @nodes_stack.push([node])
+        if @rewrite_skip_nodes.include?(ast_node)
+          @rewrite_skip_nodes.delete(ast_node)
         end
+      end
 
-        def leave(ast_node, ast_parent)
-          @nodes_stack.pop
-          @scopes_stack.pop
+      def on_fragment_spread(ast_node, ast_parent)
+        if @rewrite_skip_nodes.empty? && !skip?(ast_node)
+          # Register the irep nodes that depend on this AST node:
+          @rewrite_spread_parents[ast_node].merge(@rewrite_nodes_stack.last)
+          @rewrite_spread_scopes[ast_node] = @rewrite_scopes_stack.last
         end
+        super
+      end
+
+      def skip?(ast_node)
+        dir = ast_node.directives
+        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, @query)
       end
     end
   end

data/lib/graphql/introspection/dynamic_fields.rb

@@ -3,8 +3,14 @@ module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
       field :__typename, String, "The name of this type", null: false, extras: [:irep_node]
-      def __typename(irep_node:)
-        irep_node.owner_type.name
+
+      # `irep_node:` will be nil for the interpreter, since there is no such thing
+      def __typename(irep_node: nil)
+        if context.interpreter?
+          object.class.graphql_name
+        else
+          irep_node.owner_type.name
+        end
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -15,14 +15,19 @@ module GraphQL
       end
 
       def __type(name:)
-        type = @context.warden.get_type(name)
-        if type
+        type = context.warden.get_type(name)
+
+        if type && context.interpreter?
+          type = type.metadata[:type_class] || raise("Invariant: interpreter requires class-based type for #{name}")
+        end
+
+        # The interpreter provides this wrapping, other execution doesnt, so support both.
+        if type && !context.interpreter?
           # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = @context.schema.introspection_system.type_type
-          type_type.metadata[:type_class].authorized_new(type, @context)
-        else
-          nil
+          type_type = context.schema.introspection_system.type_type
+          type = type_type.metadata[:type_class].authorized_new(type, context)
         end
+        type
       end
     end
   end

data/lib/graphql/introspection/enum_value_type.rb

@@ -11,6 +11,10 @@ module GraphQL
       field :is_deprecated, Boolean, null: false
       field :deprecation_reason, String, null: true
 
+      def name
+        object.graphql_name
+      end
+
       def is_deprecated
         !!@object.deprecation_reason
       end

data/lib/graphql/introspection/schema_type.rb

@@ -14,7 +14,12 @@ module GraphQL
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types
-        @context.warden.types
+        types = @context.warden.types
+        if context.interpreter?
+          types.map { |t| t.metadata[:type_class] || raise("Invariant: can't introspect non-class-based type: #{t}") }
+        else
+          types
+        end
       end
 
       def query_type
@@ -30,7 +35,7 @@ module GraphQL
       end
 
       def directives
-        @object.directives.values
+        context.schema.directives.values
       end
 
       private

data/lib/graphql/introspection/type_type.rb

@@ -25,6 +25,10 @@ module GraphQL
       field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: true
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), null: true
 
+      def name
+        object.graphql_name
+      end
+
       def kind
         @object.kind.name
       end
@@ -33,7 +37,7 @@ module GraphQL
         if !@object.kind.enum?
           nil
         else
-          enum_values = @context.warden.enum_values(@object)
+          enum_values = @context.warden.enum_values(@object.graphql_definition)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -45,7 +49,7 @@ module GraphQL
 
       def interfaces
         if @object.kind == GraphQL::TypeKinds::OBJECT
-          @context.warden.interfaces(@object)
+          @context.warden.interfaces(@object.graphql_definition)
         else
           nil
         end
@@ -53,7 +57,7 @@ module GraphQL
 
       def input_fields
         if @object.kind.input_object?
-          @context.warden.arguments(@object)
+          @context.warden.arguments(@object.graphql_definition)
         else
           nil
         end
@@ -61,7 +65,7 @@ module GraphQL
 
       def possible_types
         if @object.kind.abstract?
-          @context.warden.possible_types(@object)
+          @context.warden.possible_types(@object.graphql_definition)
         else
           nil
         end
@@ -71,7 +75,7 @@ module GraphQL
         if !@object.kind.fields?
           nil
         else
-          fields = @context.warden.fields(@object)
+          fields = @context.warden.fields(@object.graphql_definition)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end

data/lib/graphql/invalid_null_error.rb

@@ -16,7 +16,7 @@ module GraphQL
       @parent_type = parent_type
       @field = field
       @value = value
-      super("Cannot return null for non-nullable field #{@parent_type.name}.#{@field.name}")
+      super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
     # @return [Hash] An entry for the response's "errors" key

data/lib/graphql/language/block_string.rb

@@ -42,6 +42,43 @@ module GraphQL
         # Rebuild the string
         lines.join("\n")
       end
+
+      def self.print(str, indent: '')
+        lines = str.split("\n")
+
+        block_str = "#{indent}\"\"\"\n".dup
+
+        lines.each do |line|
+          if line == ''
+            block_str << "\n"
+          else
+            sublines = break_line(line, 120 - indent.length)
+            sublines.each do |subline|
+              block_str << "#{indent}#{subline}\n"
+            end
+          end
+        end
+
+        block_str << "#{indent}\"\"\"\n".dup
+      end
+
+      private
+
+      def self.break_line(line, length)
+        return [line] if line.length < length + 5
+
+        parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
+        return [line] if parts.length < 4
+
+        sublines = [parts.slice!(0, 3).join]
+
+        parts.each_with_index do |part, i|
+          next if i % 2 == 1
+          sublines << "#{part[1..-1]}#{parts[i + 1]}"
+        end
+
+        sublines
+      end
     end
   end
 end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -11,7 +11,7 @@ module GraphQL
     # @param except [<#call(member, ctx)>]
     # @param include_introspection_types [Boolean] Whether or not to include introspection types in the AST
     # @param include_built_in_scalars [Boolean] Whether or not to include built in scalars in the AST
-    # @param include_built_in_directives [Boolean] Whether or not to include built in diirectives in the AST
+    # @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,
@@ -65,7 +65,7 @@ module GraphQL
         )
 
         if field.deprecation_reason
-          field_node.directives << GraphQL::Language::Nodes::Directive.new(
+          field_node = field_node.merge_directive(
             name: GraphQL::Directive::DeprecatedDirective.name,
             arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: field.deprecation_reason)]
           )
@@ -107,7 +107,7 @@ module GraphQL
         )
 
         if enum_value.deprecation_reason
-          enum_value_node.directives << GraphQL::Language::Nodes::Directive.new(
+          enum_value_node = enum_value_node.merge_directive(
             name: GraphQL::Directive::DeprecatedDirective.name,
             arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: enum_value.deprecation_reason)]
           )
@@ -124,16 +124,19 @@ module GraphQL
       end
 
       def build_argument_node(argument)
+        if argument.default_value?
+          default_value = build_default_value(argument.default_value, argument.type)
+        else
+          default_value = nil
+        end
+
         argument_node = GraphQL::Language::Nodes::InputValueDefinition.new(
           name: argument.name,
           description: argument.description,
           type: build_type_name_node(argument.type),
+          default_value: default_value,
         )
 
-        if argument.default_value?
-          argument_node.default_value = build_default_value(argument.default_value, argument.type)
-        end
-
         argument_node
       end