graphql 0.15.3 → 0.16.0

data/lib/graphql/internal_representation.rb

@@ -0,0 +1,2 @@
+require "graphql/internal_representation/node"
+require "graphql/internal_representation/rewrite"

data/lib/graphql/internal_representation/node.rb

@@ -0,0 +1,81 @@
+require "set"
+
+module GraphQL
+  module InternalRepresentation
+    class Node
+      def initialize(ast_node:, return_type: nil, on_types: Set.new, name: nil, definition: nil, children: {}, spreads: [], directives: Set.new)
+        @ast_node = ast_node
+        @return_type = return_type
+        @on_types = on_types
+        @name = name
+        @definition = definition
+        @children = children
+        @spreads = spreads
+        @directives = directives
+      end
+
+      # 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::Language::Nodes::FragmentSpreads>] 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 [GraphQL::Field, GraphQL::Directive] The definition to use to execute this node
+      attr_reader :definition
+
+      # @return [String] the name to use for the result in the response hash
+      attr_reader :name
+
+      # @return [GraphQL::Language::Nodes::AbstractNode] The AST node (or one of the nodes) where this was derived from
+      attr_reader :ast_node
+
+      # This may come from the previous field's return value or an explicitly-typed fragment
+      # @example On-type from previous return value
+      # {
+      #   person(id: 1) {
+      #     firstName # => on_type is person
+      #   }
+      # }
+      # @example On-type from explicit type condition
+      # {
+      #   node(id: $nodeId) {
+      #     ... on Nameable {
+      #       firstName # => on_type is Nameable
+      #     }
+      #   }
+      # }
+      # @return [Set<GraphQL::ObjectType, GraphQL::InterfaceType>] the types this field applies to
+      attr_reader :on_types
+
+      # @return [GraphQL::BaseType]
+      attr_reader :return_type
+
+      # @return [Array<GraphQL::Query::Node>]
+      attr_reader :children
+
+      def inspect(indent = 0)
+        own_indent = " " * indent
+        self_inspect = "#{own_indent}<Node #{name} (#{definition ? definition.name + ": " : ""}{#{on_types.to_a.join("|")}} -> #{return_type})>"
+        if children.any?
+          self_inspect << " {\n#{children.values.map { |n| n.inspect(indent + 2 )}.join("\n")}\n#{own_indent}}"
+        end
+        self_inspect
+      end
+
+      def dup
+        self.class.new({
+          ast_node: ast_node,
+          return_type: return_type,
+          on_types: on_types,
+          name: name,
+          definition: definition,
+          children: children,
+          spreads: spreads,
+          directives: directives,
+        })
+      end
+    end
+  end
+end

data/lib/graphql/internal_representation/rewrite.rb

@@ -0,0 +1,177 @@
+module GraphQL
+  module InternalRepresentation
+    # Convert an AST into a tree of {InternalRepresentation::Node}s
+    #
+    # This rides along with {StaticValidation}, building a tree of nodes.
+    #
+    # 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)
+      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
+
+        visitor[Nodes::OperationDefinition].enter << -> (ast_node, prev_ast_node) {
+          node = Node.new(
+            return_type: context.type_definition.unwrap,
+            ast_node: ast_node,
+          )
+          @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
+          # This node might not be novel, eg inside an inline fragment
+          # but it could contain new type information, which is captured below.
+          # (StaticValidation ensures that merging fields is fair game)
+          node = parent_node.children[node_name] ||= begin
+            Node.new(
+              return_type: context.type_definition && context.type_definition.unwrap,
+              ast_node: ast_node,
+              name: node_name,
+              definition: context.field_definition,
+            )
+          end
+          node.on_types.add(context.parent_type_definition.unwrap)
+          @nodes.push(node)
+          @parent_directives.push([])
+        }
+
+        visitor[Nodes::InlineFragment].enter << -> (ast_node, prev_ast_node) {
+          @parent_directives.push([])
+        }
+
+        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?
+            @parent_directives.last << Node.new(
+              name: ast_node.name,
+              ast_node: ast_node,
+              definition: context.directive_definition,
+            )
+          end
+        }
+
+        visitor[Nodes::FragmentSpread].enter << -> (ast_node, prev_ast_node) {
+          # Record _both sides_ of the dependency
+          spread_node = Node.new(
+            name: ast_node.name,
+            ast_node: ast_node,
+          )
+          parent_node = @nodes.last
+          # 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::FragmentDefinition].enter << -> (ast_node, prev_ast_node) {
+          node = Node.new(
+            name: ast_node.name,
+            return_type: context.type_definition,
+            ast_node: ast_node,
+          )
+          @nodes.push(node)
+          @fragments[ast_node.name] = node
+        }
+
+        visitor[Nodes::InlineFragment].leave  << -> (ast_node, prev_ast_node) {
+          @parent_directives.pop
+        }
+
+        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
+          spread_node.directives.merge(@parent_directives.flatten)
+          @parent_directives.pop
+        }
+
+        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 frag_node.spreads.none?
+            @independent_fragments << frag_node
+          end
+        }
+
+        visitor[Nodes::OperationDefinition].leave << -> (ast_node, prev_ast_node) {
+          @nodes.pop
+        }
+
+        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
+          field_node.directives.merge(@parent_directives.flatten)
+          @parent_directives.pop
+        }
+
+        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
+              # remove self from dependent_node.spreads
+              rejected_spread_nodes = dependent_node.spreads.select { |spr| spr.name == fragment_node.name }
+              rejected_spread_nodes.each { |r_node| dependent_node.spreads.delete(r_node) }
+
+              # resolve the dependency (merge into dependent node)
+              deep_merge(dependent_node, fragment_node, rejected_spread_nodes.first.directives)
+
+              if dependent_node.spreads.none? && dependent_node.ast_node.is_a?(Nodes::FragmentDefinition)
+                @independent_fragments.push(dependent_node)
+              end
+            end
+          end
+        }
+      end
+
+      private
+
+      # Merge the chilren from `fragment_node` into `parent_node`. Merge `directives` into each of those fields.
+      def deep_merge(parent_node, fragment_node, directives)
+        fragment_node.children.each do |name, child_node|
+          deep_merge_child(parent_node, name, child_node, directives)
+        end
+      end
+
+      # Merge `node` into `parent_node`'s children, as `name`, applying `extra_directives`
+      def deep_merge_child(parent_node, name, node, extra_directives)
+        child_node = parent_node.children[name] ||= node.dup
+        node.children.each do |merge_child_name, merge_child_node|
+          deep_merge_child(child_node, merge_child_name, merge_child_node, [])
+        end
+        child_node.directives.merge(extra_directives)
+      end
+    end
+  end
+end

data/lib/graphql/language/visitor.rb

@@ -4,12 +4,12 @@ module GraphQL
     #
     # @example Create a visitor, add hooks, then search a document
     #   total_field_count = 0
-    #   visitor = GraphQL::Language::Visitor.new
+    #   visitor = GraphQL::Language::Visitor.new(document)
     #   # Whenever you find a field, increment the field count:
     #   visitor[GraphQL::Language::Nodes::Field] << -> (node) { total_field_count += 1 }
     #   # When we finish, print the field count:
     #   visitor[GraphQL::Language::Nodes::Document].leave << -> (node) { p total_field_count }
-    #   visitor.visit(document)
+    #   visitor.visit
     #   # => 6
     #
     class Visitor
@@ -22,7 +22,8 @@ module GraphQL
       # @return [Array<Proc>] Hooks to call when leaving _any_ node
       attr_reader :leave
 
-      def initialize
+      def initialize(document)
+        @document = document
         @visitors = {}
         @enter = []
         @leave = []
@@ -38,17 +39,22 @@ module GraphQL
         @visitors[node_class] ||= NodeVisitor.new
       end
 
-      # Visit `root` and all children, applying hooks as you go
-      # @param root [GraphQL::Language::Nodes::AbstractNode] some node to start parsing on
+      # Visit `document` and all children, applying hooks as you go
       # @return [void]
-      def visit(root, parent=nil)
-        begin_visit(root, parent) &&
-          root.children.reduce(true) { |memo, child| memo && visit(child, root) }
-        end_visit(root, parent)
+      def visit
+        visit_node(@document, nil)
       end
 
       private
 
+      def visit_node(node, parent)
+        begin_hooks_ok = begin_visit(node, parent)
+        if begin_hooks_ok
+          node.children.reduce(true) { |memo, child| memo && visit_node(child, node) }
+        end
+        end_visit(node, parent)
+      end
+
       def begin_visit(node, parent)
         self.class.apply_hooks(enter, node, parent)
         node_visitor = self[node.class]

data/lib/graphql/object_type.rb

@@ -24,7 +24,7 @@ module GraphQL
     accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
     attr_accessor :name, :description
 
-    # @return [Hash<String, GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
+    # @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
     attr_accessor :fields
 
     def initialize

data/lib/graphql/query.rb

@@ -8,7 +8,7 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth
+    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -18,11 +18,21 @@ module GraphQL
     # @param validate [Boolean] if true, `query_string` will be validated with {StaticValidation::Validator}
     # @param operation_name [String] if the query string contains many operations, this is the one which should be executed
     # @param root_value [Object] the object used to resolve fields on the root type
-    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil)
+    # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
+    # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
+    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil)
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
       @schema = schema
       @max_depth = max_depth || schema.max_depth
+      @max_complexity = max_complexity || schema.max_complexity
+      @query_analyzers = schema.query_analyzers.dup
+      if @max_depth
+        @query_analyzers << GraphQL::Analysis::MaxQueryDepth.new(@max_depth)
+      end
+      if @max_complexity
+        @query_analyzers << GraphQL::Analysis::MaxQueryComplexity.new(@max_complexity)
+      end
       @context = Context.new(query: self, values: context)
       @root_value = root_value
       @validate = validate
@@ -30,6 +40,7 @@ module GraphQL
       @fragments = {}
       @operations = {}
       @provided_variables = variables
+      @query_string = query_string
 
       @document = document || GraphQL.parse(query_string)
       @document.definitions.each do |part|
@@ -39,15 +50,20 @@ module GraphQL
           @operations[part.name] = part
         end
       end
+
+      @arguments_cache = {}
     end
 
     # Get the result for this query, executing it once
     def result
-      if @validate && validation_errors.any?
-        return { "errors" => validation_errors }
+      @result ||= begin
+        if @validate && (validation_errors.any? || analysis_errors.any?)
+          { "errors" => validation_errors + analysis_errors}
+        else
+          Executor.new(self).result
+        end
       end
 
-      @result ||= Executor.new(self).result
     end
 
 
@@ -71,10 +87,39 @@ module GraphQL
       )
     end
 
-    private
+    def internal_representation
+      @internal_representation ||= begin
+        perform_validation
+        @internal_representation
+      end
+    end
 
     def validation_errors
-      @validation_errors ||= schema.static_validator.validate(self)
+      @validation_errors ||= begin
+        perform_validation
+        @validation_errors
+      end
+    end
+
+    # Node-level cache for calculating arguments. Used during execution and query analysis.
+    # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
+    def arguments_for(irep_node)
+      @arguments_cache[irep_node] ||= begin
+        GraphQL::Query::LiteralInput.from_arguments(
+          irep_node.ast_node.arguments,
+          irep_node.definition.arguments,
+          self.variables
+        )
+      end
+    end
+
+    private
+
+    def perform_validation
+      validation_result = schema.static_validator.validate(self)
+      @validation_errors = validation_result[:errors]
+      @internal_representation = validation_result[:irep]
+      nil
     end
 
 
@@ -89,6 +134,20 @@ module GraphQL
         operations[operation_name]
       end
     end
+
+    def analysis_errors
+      @analysis_errors ||= begin
+        if validation_errors.any?
+          # Can't reduce an invalid query
+          []
+        elsif @query_analyzers.any?
+          reduce_results = GraphQL::Analysis.analyze_query(self, @query_analyzers)
+          reduce_results.select { |r| r.is_a?(GraphQL::AnalysisError) }.map(&:to_h)
+        else
+          []
+        end
+      end
+    end
   end
 end