graphql 1.4.5 → 1.5.3

data/lib/graphql/id_type.rb

@@ -6,7 +6,7 @@ GraphQL::ID_TYPE = GraphQL::ScalarType.define do
   coerce_result ->(value) { value.to_s }
   coerce_input ->(value) {
     case value
-    when String, Fixnum, Bignum
+    when String, Integer
       value.to_s
     else
       nil

data/lib/graphql/input_object_type.rb

@@ -31,7 +31,7 @@ module GraphQL
     )
 
     attr_accessor :mutation, :arguments
-    ensure_defined(:mutation, :arguments)
+    ensure_defined(:mutation, :arguments, :input_fields)
     alias :input_fields :arguments
 
     # @!attribute mutation

data/lib/graphql/internal_representation.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 require "graphql/internal_representation/node"
 require "graphql/internal_representation/rewrite"
-require "graphql/internal_representation/selection"
+require "graphql/internal_representation/visit"

data/lib/graphql/internal_representation/node.rb

@@ -1,129 +1,57 @@
 # frozen_string_literal: true
-require "set"
-
 module GraphQL
   module InternalRepresentation
     class Node
-      def initialize(parent:, ast_node: nil, return_type: nil, owner_type: nil, name: nil, definition_name: nil, definition: nil, spreads: [], directives: Set.new, included: true, typed_children: Hash.new {|h, k| h[k] = {} }, definitions: {}, children: {})
-        @ast_node = ast_node
-        @return_type = return_type
-        @owner_type = owner_type
-        @name = name
-        @definition_name = definition_name
-        @definition = definition
-        @parent = parent
-        @spreads = spreads
-        @directives = directives
-        @included = included
-        @typed_children = typed_children
-        @children = children
-        @definitions = definitions
-      end
-
-      # @return [Hash{GraphQL::BaseType => Hash{String => Node}] Children for each type condition
-      attr_reader :typed_children
-
-      # Note: by the time this gets out of the Rewrite phase, this will be empty -- it's emptied out when fragments are merged back in
-      # @return [Array<GraphQL::InternalRepresentation::Node>] Fragment names that were spread in this node
-      attr_reader :spreads
-
-      # These are the compiled directives from fragment spreads, inline fragments, and the field itself
-      # @return [Set<GraphQL::Language::Nodes::Directive>]
-      attr_reader :directives
-
-      # @return [String] the name for this node's definition ({#name} may be a field's alias, this is always the name)
-      attr_reader :definition_name
+      # @return [String] the name this node has in the response
+      attr_reader :name
 
-      # A _shallow_ cache of type-field pairs for executing & analyzing this node.
-      #
-      # Known to be buggy: some fields are deeply merged when they shouldn't be.
-      #
-      # @example On-type from previous return value
-      # {
-      #   person(id: 1) {
-      #     firstName # => defined type is person
-      #   }
-      # }
-      # @example On-type from explicit type condition
-      # {
-      #   node(id: $nodeId) {
-      #     ... on Nameable {
-      #       firstName # => defined type is Nameable
-      #     }
-      #   }
-      # }
-      # @deprecated use {#typed_children} to find matching children, the use the node's {#definition}
-      # @return [Hash<GraphQL::BaseType => GraphQL::Field>] definitions to use for each possible type
-      attr_reader :definitions
+      # @return [GraphQL::ObjectType]
+      attr_reader :owner_type
 
-      # @return [GraphQL::Field, GraphQL::Directive] the static definition for this field (it might be an interface field definition even though an object field definition will be used at runtime)
-      attr_reader :definition
+      # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>] selections on this node for each type
+      attr_reader :typed_children
 
-      # @return [String] the name to use for the result in the response hash
-      attr_reader :name
+      # @return [Set<Language::Nodes::AbstractNode>] AST nodes which are represented by this node
+      def ast_nodes
+        @ast_nodes ||= Set.new
+      end
 
-      # @return [GraphQL::Language::Nodes::AbstractNode] The AST node (or one of the nodes) where this was derived from
-      attr_reader :ast_node
+      # @return [Set<GraphQL::Field>] Field definitions for this node (there should only be one!)
+      def definitions
+        @definitions ||= Set.new
+      end
 
       # @return [GraphQL::BaseType]
       attr_reader :return_type
 
-      # @return [GraphQL::BaseType]
-      attr_reader :owner_type
-
-      # Returns leaf selections on this node.
-      # Known to be buggy: deeply nested selections are not handled properly
-      # @deprecated use {#typed_children} instead
-      # @return [Array<Node>]
-      attr_reader :children
-
-      # @return [Boolean] false if every field for this node included `@skip(if: true)`
-      attr_accessor :included
-      alias :included? :included
-
-      def skipped?
-        !@included
+      def initialize(
+          name:, owner_type:, query:, return_type:,
+          ast_nodes: nil,
+          definitions: nil, typed_children: nil
+        )
+        @name = name
+        @query = query
+        @owner_type = owner_type
+        @typed_children = typed_children || Hash.new { |h1, k1| h1[k1] = {} }
+        @ast_nodes = ast_nodes
+        @definitions = definitions
+        @return_type = return_type
       end
 
-      # @return [GraphQL::InternalRepresentation::Node] The node which this node is a child of
-      attr_reader :parent
-
-      # @return [GraphQL::InternalRepresentation::Node] The root node which this node is a (perhaps-distant) child of, or `self` if this is a root node
-      def owner
-        @owner ||= begin
-          if parent.nil?
-            self
-          else
-            parent.owner
-          end
-        end
+      def definition_name
+        @definition_name ||= definition.name
       end
 
-      def path
-        warn("InternalRepresentation::Node#path is deprecated, use Query::Context#path instead")
-        if parent
-          path = parent.path
-          path << name
-          path << @index if @index
-          path
-        else
-          []
-        end
+      def definition
+        @definition ||= definitions.first
       end
 
-      attr_writer :index
+      def ast_node
+        @ast_node ||= ast_nodes.first
+      end
 
-      def inspect(indent = 0)
-        own_indent = " " * indent
-        self_inspect = "#{own_indent}<Node #{name} #{skipped? ? "(skipped)" : ""}(#{definition_name} -> #{return_type})>".dup
-        if typed_children.any?
-          self_inspect << " {"
-          typed_children.each do |type_defn, children|
-            self_inspect << "\n#{own_indent}  #{type_defn} => (#{children.keys.join(",")})"
-          end
-          self_inspect << "\n#{own_indent}}"
-        end
-        self_inspect
+      def inspect
+        "#<Node #{@owner_type}.#{@name} -> #{@return_type}>"
       end
     end
   end

data/lib/graphql/internal_representation/rewrite.rb

@@ -1,238 +1,244 @@
 # frozen_string_literal: true
 module GraphQL
   module InternalRepresentation
-    # Convert an AST into a tree of {InternalRepresentation::Node}s
+    # While visiting an AST, build a normalized, flattened tree of {InternalRepresentation::Node}s.
     #
-    # This rides along with {StaticValidation}, building a tree of nodes.
+    # No unions or interfaces are present in this tree, only object types.
+    #
+    # Selections from the AST are attached to the object types they apply to.
+    #
+    # Inline fragments and fragment spreads are preserved in {InternalRepresentation::Node#ast_spreads},
+    # where they can be used to check for the presence of directives. This might not be sufficient
+    # for future directives, since the selections' grouping is lost.
+    #
+    # The rewritten query tree serves as the basis for the `FieldsWillMerge` validation.
     #
-    # However, if any errors occurred during validation, the resulting tree is bogus.
-    #  (For example, `nil` could have been pushed instead of a type.)
     class Rewrite
       include GraphQL::Language
 
-      # @return [Hash<String => InternalRepresentation::Node>] internal representation of each query root (operation, fragment)
+      NO_DIRECTIVES = [].freeze
+
+      # @return [Hash<String, Node>] Roots of this query
       attr_reader :operations
 
       def initialize
-        # { String => Node } Tracks the roots of the query
         @operations = {}
-        @fragments = {}
-        # [String...] fragments which don't have fragments inside them
-        @independent_fragments = []
-        # Tracks the current node during traversal
-        # Stack<InternalRepresentation::Node>
-        @nodes = []
-        # This tracks dependencies from fragment to Node where it was used
-        # { frag_name => [dependent_node, dependent_node]}
-        @fragment_spreads = Hash.new { |h, k| h[k] = []}
-        # [[Nodes::Directive ...]] directive affecting the current scope
-        @parent_directives = []
       end
 
       def validate(context)
         visitor = context.visitor
+        query = context.query
+        # 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 }
+        # Array<Set<InternalRepresentation::Node>>
+        # The current point of the irep_tree during visitation
+        nodes_stack = []
+        # Array<Set<GraphQL::ObjectType>>
+        # Object types that the current point of the irep_tree applies to
+        scope_stack = []
+        fragment_definitions = {}
+        skip_nodes = Set.new
+
+        visit_op = VisitDefinition.new(context, @operations, nodes_stack, scope_stack)
+        visitor[Nodes::OperationDefinition].enter << visit_op.method(:enter)
+        visitor[Nodes::OperationDefinition].leave << visit_op.method(:leave)
+
+        visit_frag = VisitDefinition.new(context, fragment_definitions, nodes_stack, scope_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
 
-        visitor[Nodes::OperationDefinition].enter << ->(ast_node, prev_ast_node) {
-          node = Node.new(
-            return_type: context.type_definition && context.type_definition.unwrap,
-            ast_node: ast_node,
-            name: ast_node.name,
-            parent: nil,
-          )
-          @nodes.push(node)
-          @operations[ast_node.name] = node
-        }
-
-        visitor[Nodes::Field].enter << ->(ast_node, prev_ast_node) {
-          parent_node = @nodes.last
-          node_name = ast_node.alias || ast_node.name
-          owner_type = context.parent_type_definition.unwrap
-          # This node might not be novel, eg inside an inline fragment
-          node = parent_node.typed_children[owner_type][node_name] ||= Node.new(
-            return_type: context.type_definition && context.type_definition.unwrap,
-            ast_node: ast_node,
-            name: node_name,
-            definition_name: ast_node.name,
-            definition: context.field_definition,
-            parent: parent_node,
-            owner_type: owner_type,
-            included: false, # may be set to true on leaving the node
-          )
-          parent_node.children[node_name] ||= node
-          node.definitions[owner_type] = context.field_definition
-          @nodes.push(node)
-          @parent_directives.push([])
-        }
-
-        visitor[Nodes::InlineFragment].enter << ->(ast_node, prev_ast_node) {
-          @parent_directives.push(InlineFragmentDirectives.new)
-        }
-
-        visitor[Nodes::Directive].enter << ->(ast_node, prev_ast_node) {
-          # It could be a query error where a directive is somewhere it shouldn't be
-          if @parent_directives.any?
-            directive_irep_node = Node.new(
-              name: ast_node.name,
-              definition_name: ast_node.name,
-              ast_node: ast_node,
-              definition: context.directive_definition,
-              definitions: {context.directive_definition => context.directive_definition},
-              # This isn't used, the directive may have many parents in the case of inline fragment
-              parent: nil,
-            )
-            @parent_directives.last.push(directive_irep_node)
+          if skip_nodes.none?
+            next_scope = Set.new
+            prev_scope = scope_stack.last
+            each_type(query, context.type_definition) do |obj_type|
+              # What this fragment can apply to is also determined by
+              # the scope around it (it can't widen the scope)
+              if prev_scope.include?(obj_type)
+                next_scope.add(obj_type)
+              end
+            end
+            scope_stack.push(next_scope)
           end
         }
 
-        visitor[Nodes::FragmentSpread].enter << ->(ast_node, prev_ast_node) {
-          parent_node = @nodes.last
-          # Record _both sides_ of the dependency
-          spread_node = Node.new(
-            parent: parent_node,
-            name: ast_node.name,
-            ast_node: ast_node,
-            included: false, # this may be set to true on leaving the node
-          )
-          # The parent node has a reference to the fragment
-          parent_node.spreads.push(spread_node)
-          # And keep a reference from the fragment to the parent node
-          @fragment_spreads[ast_node.name].push(parent_node)
-          @nodes.push(spread_node)
-          @parent_directives.push([])
-        }
+        visitor[Nodes::InlineFragment].leave << ->(ast_node, ast_parent) {
+          if skip_nodes.none?
+            scope_stack.pop
+          end
 
-        visitor[Nodes::FragmentDefinition].enter << ->(ast_node, prev_ast_node) {
-          node = Node.new(
-            parent: nil,
-            name: ast_node.name,
-            return_type: context.type_definition,
-            ast_node: ast_node,
-          )
-          @nodes.push(node)
-          @fragments[ast_node.name] = node
+          if skip_nodes.include?(ast_node)
+            skip_nodes.delete(ast_node)
+          end
         }
 
-        visitor[Nodes::InlineFragment].leave  << ->(ast_node, prev_ast_node) {
-          @parent_directives.pop
-        }
+        visitor[Nodes::Field].enter << ->(ast_node, ast_parent) {
+          if skip?(ast_node, query)
+            skip_nodes.add(ast_node)
+          end
 
-        visitor[Nodes::FragmentSpread].leave  << ->(ast_node, prev_ast_node) {
-          # Capture any directives that apply to this spread
-          # so that they can be applied to fields when
-          # the fragment is merged in later
-          spread_node = @nodes.pop
-          applicable_directives = pop_applicable_directives(@parent_directives)
-          spread_node.included ||= GraphQL::Execution::DirectiveChecks.include?(applicable_directives, context.query)
-          spread_node.directives.merge(applicable_directives)
+          if skip_nodes.none?
+            node_name = ast_node.alias || ast_node.name
+            parent_nodes = nodes_stack.last
+            next_nodes = []
+            next_scope = Set.new
+            applicable_scope = scope_stack.last
+
+            applicable_scope.each do |obj_type|
+              # Can't use context.field_definition because that might be
+              # a definition on an interface type
+              field_defn = query.get_field(obj_type, ast_node.name)
+              if field_defn.nil?
+                # It's a non-existent field
+              else
+                field_return_type = field_defn.type.unwrap
+                each_type(query, field_return_type) do |obj_type|
+                  next_scope.add(obj_type)
+                end
+                parent_nodes.each do |parent_node|
+                  node = parent_node.typed_children[obj_type][node_name] ||= Node.new(
+                    name: node_name,
+                    owner_type: obj_type,
+                    query: query,
+                    return_type: field_return_type,
+                  )
+                  node.ast_nodes.add(ast_node)
+                  node.definitions.add(field_defn)
+                  next_nodes << node
+                end
+              end
+            end
+            nodes_stack.push(next_nodes)
+            scope_stack.push(next_scope)
+          end
         }
 
-        visitor[Nodes::FragmentDefinition].leave << ->(ast_node, prev_ast_node) {
-          # This fragment doesn't depend on any others,
-          # we should save it as the starting point for dependency resolution
-          frag_node = @nodes.pop
-          if !any_fragment_spreads?(frag_node)
-            @independent_fragments << frag_node
+        visitor[Nodes::Field].leave << ->(ast_node, ast_parent) {
+          if skip_nodes.none?
+            nodes_stack.pop
+            scope_stack.pop
           end
-        }
 
-        visitor[Nodes::OperationDefinition].leave << ->(ast_node, prev_ast_node) {
-          @nodes.pop
+          if skip_nodes.include?(ast_node)
+            skip_nodes.delete(ast_node)
+          end
         }
 
-        visitor[Nodes::Field].leave << ->(ast_node, prev_ast_node) {
-          # Pop this field's node
-          # and record any directives that were visited
-          # during this field & before it (eg, inline fragments)
-          field_node = @nodes.pop
-          applicable_directives = pop_applicable_directives(@parent_directives)
-          field_node.directives.merge(applicable_directives)
-          field_node.included ||= GraphQL::Execution::DirectiveChecks.include?(applicable_directives, context.query)
+        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)
+          end
         }
 
-        visitor[Nodes::Document].leave << ->(ast_node, prev_ast_node) {
-          # Resolve fragment dependencies. Start with fragments with no
-          # dependencies and work along the spreads.
-          while fragment_node = @independent_fragments.pop
-            fragment_usages = @fragment_spreads[fragment_node.name]
-            while dependent_node = fragment_usages.pop
-              # Find the spreads for this reference
-              resolved_spread_nodes = dependent_node.spreads.select { |spr| spr.name == fragment_node.name }
-              spread_is_included = resolved_spread_nodes.any?(&:included?)
-              # Since we're going to resolve them, remove them from the dependcies
-              resolved_spread_nodes.each { |r_node| dependent_node.spreads.delete(r_node) }
-
-              # resolve the dependency (merge into dependent node)
-              deep_merge(dependent_node, fragment_node, spread_is_included)
-              owner = dependent_node.owner
-              if owner.ast_node.is_a?(Nodes::FragmentDefinition) && !any_fragment_spreads?(owner)
-                @independent_fragments.push(owner)
+        # Resolve fragment spreads.
+        # Fragment definitions got their own irep trees during visitation.
+        # Those nodes are spliced in verbatim (not copied), but this is OK
+        # because fragments are resolved from the "bottom up", each fragment
+        # 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
+          spread_ast_nodes.each do |spread_ast_node|
+            parent_nodes = spread_parents[spread_ast_node]
+            parent_nodes.each do |parent_node|
+              fragment_node = fragment_definitions[frag_name]
+              if fragment_node
+                deep_merge_selections(query, parent_node, fragment_node)
               end
             end
           end
-        }
+        end
       end
 
-      private
-
-      # Merge the children from `fragment_node` into `parent_node`.
-      # This is an implementation of "fragment inlining"
-      def deep_merge(parent_node, fragment_node, included)
-        fragment_node.typed_children.each do |type_defn, children|
-          children.each do |name, child_node|
-            deep_merge_child(parent_node, type_defn, name, child_node, included)
+      # Merge selections from `new_parent` into `prev_parent`.
+      # If `new_parent` came from a spread in the AST, it's present as `spread`.
+      # Selections are merged in place, not copied.
+      def deep_merge_selections(query, prev_parent, new_parent)
+        new_parent.typed_children.each do |obj_type, new_fields|
+          prev_fields = prev_parent.typed_children[obj_type]
+          new_fields.each do |name, new_node|
+            prev_node = prev_fields[name]
+            if prev_node
+              prev_node.ast_nodes.merge(new_node.ast_nodes)
+              prev_node.definitions.merge(new_node.definitions)
+              deep_merge_selections(query, prev_node, new_node)
+            else
+              prev_fields[name] = new_node
+            end
           end
         end
       end
 
-      # Merge `node` into `parent_node`'s children, as `name`, applying `extra_included`
-      # `extra_included` comes from the spread node:
-      # - If the spread was included, first-level children should be included if _either_ node was included
-      # - If the spread was _not_ included, first-level children should be included if _a pre-existing_ node was included
-      #   (A copied node should be excluded)
-      def deep_merge_child(parent_node, type_defn, name, node, extra_included)
-        child_node = parent_node.typed_children[type_defn][name]
-        previously_included = child_node.nil? ? false : child_node.included?
-        next_included = extra_included ? (previously_included || node.included?) : previously_included
-
-        if child_node.nil?
-          child_node = parent_node.typed_children[type_defn][name] = node.dup
-        end
-
-        child_node.included = next_included
+      # @see {.each_type}
+      def each_type(query, owner_type, &block)
+        self.class.each_type(query, owner_type, &block)
+      end
 
-        node.typed_children.each do |type_defn, children|
-          children.each do |merge_child_name, merge_child_node|
-            deep_merge_child(child_node, type_defn, merge_child_name, merge_child_node, node.included)
-          end
+      # Call the block for each of `owner_type`'s possible types
+      def self.each_type(query, owner_type)
+        case owner_type
+        when GraphQL::ObjectType, GraphQL::ScalarType, GraphQL::EnumType
+          yield(owner_type)
+        when GraphQL::UnionType, GraphQL::InterfaceType
+          query.possible_types(owner_type).each(&Proc.new)
+        when GraphQL::InputObjectType, nil
+          # this is an error, don't give 'em nothin
+        else
+          raise "Unexpected owner type: #{owner_type.inspect}"
         end
       end
 
-      # return true if node or _any_ children have a fragment spread
-      def any_fragment_spreads?(node)
-        node.spreads.any? || node.typed_children.any? { |type_defn, children| children.any? { |name, node| any_fragment_spreads?(node) } }
+      def skip?(ast_node, query)
+        dir = ast_node.directives
+        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
       end
 
-      # pop off own directives,
-      # then check the last one to see if it's directives
-      # from an inline fragment. If it is, add them in
-      # @return [Array<Node>]
-      def pop_applicable_directives(directive_stack)
-        own_directives = directive_stack.pop
-        if directive_stack.last.is_a?(InlineFragmentDirectives)
-          own_directives = directive_stack.last + own_directives
+      class VisitDefinition
+        def initialize(context, definitions, nodes_stack, scope_stack)
+          @context = context
+          @query = context.query
+          @definitions = definitions
+          @nodes_stack = nodes_stack
+          @scope_stack = scope_stack
         end
-        own_directives
-      end
 
+        def enter(ast_node, ast_parent)
+          # Either QueryType or the fragment type condition
+          owner_type = @context.type_definition && @context.type_definition.unwrap
+          next_nodes = []
+          next_scope = Set.new
+          defn_name = ast_node.name
+          Rewrite.each_type(@query, owner_type) do |obj_type|
+            next_scope.add(obj_type)
+          end
 
-      # It's an array, but can be identified with `is_a?`
-      class InlineFragmentDirectives
-        extend Forwardable
-        def initialize
-          @storage = []
+          node = Node.new(
+            name: defn_name,
+            owner_type: owner_type,
+            query: @query,
+            ast_nodes: Set.new([ast_node]),
+            return_type: owner_type,
+          )
+          @definitions[defn_name] = node
+          next_nodes << node
+
+          @nodes_stack.push(next_nodes)
+          @scope_stack.push(next_scope)
         end
 
-        def_delegators :@storage, :push, :+
+        def leave(ast_node, ast_parent)
+          @nodes_stack.pop
+          @scope_stack.pop
+        end
       end
     end
   end