graphql 0.18.14 → 0.18.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8692b90c4aa941fe5a1139719790eb1ba55c92e
-  data.tar.gz: 84c924ce93a593f26a7419f9ed69e5220380201c
+  metadata.gz: ca81d77891fe081da31667ba3d1a8676ff489ff5
+  data.tar.gz: e2b4a12d439ce76943470264e60d6007ae7f61fb
 SHA512:
-  metadata.gz: 26a2968e15530d07b78b293f41bc103fdc3026036de39fd84e0f48434659d23558d806e67b7d07288cd5eb9b6f08cfbb06e76d809b865d35c70355cd7ad51ae7
-  data.tar.gz: 9c3401de8f427e468db33e2403b729ec5ccc291b53e95d8d853ef86e28744cfec291c5df778f34c8497149d82f4aa3054ddb0ff8059516e973f0fbc2441e999d
+  metadata.gz: d18944b50b350786c710bc9e9ca3f9e463ccc8a6d835fa3b24e2442120e4b41280828ec59ad4e916b5aa3bea5f0566b9fb9bb6a462eaa75dcc7397d9099f5892
+  data.tar.gz: 78b22a36ffbed73b1b512c8b351cc55f99a8484139ac71fd1f8f4dc2a9f7682b68c681e5a16d8b7776500b24cd721ac576519566dae87c0bb94c97536651eca6

data/lib/graphql/analysis/query_complexity.rb

@@ -18,10 +18,13 @@ module GraphQL
       # State for the query complexity calcuation:
       # - `query` is needed for variables, then passed to handler
       # - `complexities_on_type` holds complexity scores for each type in an IRep node
+      # - `skip_depth` increments for each skipped node, then decrements on the way out.
+      #   While it's greater than `0`, we're visiting a skipped part of the query.
       def initial_value(query)
         {
           query: query,
           complexities_on_type: [TypeComplexity.new],
+          skip_depth: 0,
         }
       end
 
@@ -29,16 +32,22 @@ module GraphQL
       def call(memo, visit_type, irep_node)
         if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
           if visit_type == :enter
-            memo[:complexities_on_type].push(TypeComplexity.new)
+            if irep_node.skipped?
+              memo[:skip_depth] += 1
+            elsif memo[:skip_depth] == 0
+              memo[:complexities_on_type].push(TypeComplexity.new)
+            end
           else
-            type_complexities = memo[:complexities_on_type].pop
-            own_complexity = if GraphQL::Execution::DirectiveChecks.skip?(irep_node, memo[:query])
-              0
+            if memo[:skip_depth] > 0
+              if irep_node.skipped?
+                memo[:skip_depth] -= 1
+              end
             else
+              type_complexities = memo[:complexities_on_type].pop
               child_complexity = type_complexities.max_possible_complexity
-              get_complexity(irep_node, memo[:query], child_complexity)
+              own_complexity = get_complexity(irep_node, memo[:query], child_complexity)
+              memo[:complexities_on_type].last.merge(irep_node.definitions, own_complexity)
             end
-            memo[:complexities_on_type].last.merge(irep_node.definitions, own_complexity)
           end
         end
         memo

data/lib/graphql/analysis/query_depth.rb

@@ -16,26 +16,27 @@ module GraphQL
         {
           max_depth: 0,
           current_depth: 0,
-          skip_current_scope: false,
+          skip_depth: 0,
           query: query,
         }
       end
 
       def call(memo, visit_type, irep_node)
         if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
+          # Don't validate introspection fields or skipped nodes
+          not_validated_node = GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name) || !irep_node.included?
           if visit_type == :enter
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
-              # Don't validate introspection fields
-              memo[:skip_current_scope] = true
-            elsif memo[:skip_current_scope]
-              # we're inside an introspection query
-            elsif GraphQL::Execution::DirectiveChecks.include?(irep_node, memo[:query])
+            if not_validated_node
+              memo[:skip_depth] += 1
+            elsif memo[:skip_depth] > 0
+              # we're inside an introspection query or skipped node
+            else
               memo[:current_depth] += 1
             end
           else
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
-              memo[:skip_current_scope] = false
-            elsif GraphQL::Execution::DirectiveChecks.include?(irep_node, memo[:query])
+            if not_validated_node
+              memo[:skip_depth] -= 1
+            else
               if memo[:max_depth] < memo[:current_depth]
                 memo[:max_depth] = memo[:current_depth]
               end

data/lib/graphql/directive.rb

@@ -7,9 +7,9 @@ module GraphQL
   #
   class Directive
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :include_proc, argument: GraphQL::Define::AssignArgument
+    accepts_definitions :locations, :name, :description, argument: GraphQL::Define::AssignArgument
 
-    lazy_defined_attr_accessor :locations, :arguments, :name, :description, :include_proc
+    lazy_defined_attr_accessor :locations, :arguments, :name, :description
 
     LOCATIONS = [
       QUERY =               :QUERY,
@@ -25,10 +25,6 @@ module GraphQL
       @arguments = {}
     end
 
-    def include?(arguments)
-      include_proc.call(arguments)
-    end
-
     def to_s
       "<GraphQL::Directive #{name}>"
     end

data/lib/graphql/directive/include_directive.rb

@@ -3,8 +3,4 @@ GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
   description "Include this part of the query if `if` is true"
   locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
   argument :if, !GraphQL::BOOLEAN_TYPE
-
-  include_proc -> (arguments) {
-    arguments["if"]
-  }
 end

data/lib/graphql/directive/skip_directive.rb

@@ -4,8 +4,4 @@ GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
   locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
 
   argument :if, !GraphQL::BOOLEAN_TYPE
-
-  include_proc -> (arguments) {
-    !arguments["if"]
-  }
 end

data/lib/graphql/execution/directive_checks.rb

@@ -10,22 +10,31 @@ module GraphQL
 
       # This covers `@include(if:)` & `@skip(if:)`
       # @return [Boolean] Should this node be skipped altogether?
-      def skip?(irep_node, query)
-        irep_node.directives.each do |directive_node|
-          if directive_node.name == SKIP || directive_node.name == INCLUDE
-            directive_defn = directive_node.definitions.first
-            args = query.arguments_for(directive_node, directive_defn)
-            if !directive_defn.include?(args)
-              return true
-            end
-          end
-        end
-        false
+      def skip?(ast_node, query)
+        !include?(ast_node, query)
       end
 
       # @return [Boolean] Should this node be included in the query?
-      def include?(irep_node, query)
-        !skip?(irep_node, query)
+      def include?(directive_irep_nodes, query)
+        directive_irep_nodes.each do |directive_irep_node|
+          name = directive_irep_node.name
+          directive_defn = query.schema.directives[name]
+          case name
+          when SKIP
+            args = query.arguments_for(directive_irep_node, directive_defn)
+            if args['if'] == true
+              return false
+            end
+          when INCLUDE
+            args = query.arguments_for(directive_irep_node, directive_defn)
+            if args['if'] == false
+              return false
+            end
+          else
+            # Undefined directive, or one we don't care about
+          end
+        end
+        true
       end
     end
   end

data/lib/graphql/execution_error.rb

@@ -6,6 +6,10 @@ module GraphQL
     # @return [GraphQL::Language::Nodes::Field] the field where the error occured
     attr_accessor :ast_node
 
+    # @return [String] an array describing the JSON-path into the execution
+    # response which corresponds to this error.
+    attr_accessor :path
+
     def initialize(message, ast_node: nil)
       @ast_node = ast_node
       super(message)
@@ -24,6 +28,9 @@ module GraphQL
           }
         ]
       end
+      if path
+        hash["path"] = path
+      end
       hash
     end
   end

data/lib/graphql/internal_representation/node.rb

@@ -3,7 +3,7 @@ require "set"
 module GraphQL
   module InternalRepresentation
     class Node
-      def initialize(parent:, ast_node: nil, return_type: nil, name: nil, definition_name: nil, definitions: {}, children: {}, spreads: [], directives: Set.new)
+      def initialize(parent:, ast_node: nil, return_type: nil, name: nil, definition_name: nil, definitions: {}, children: {}, spreads: [], directives: Set.new, included: true)
         # Make sure these are kept in sync with #dup
         @ast_node = ast_node
         @return_type = return_type
@@ -14,6 +14,7 @@ module GraphQL
         @children = children
         @spreads = spreads
         @directives = directives
+        @included = included
       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
@@ -58,6 +59,14 @@ module GraphQL
       # @return [Array<GraphQL::Query::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
+      end
+
       # @return [GraphQL::InternalRepresentation::Node] The node which this node is a child of
       attr_reader :parent
 
@@ -72,9 +81,18 @@ module GraphQL
         end
       end
 
+      def path
+        path = parent ? parent.path : []
+        path << name if name
+        path << @index if @index
+        path
+      end
+
+      attr_writer :index
+
       def inspect(indent = 0)
         own_indent = " " * indent
-        self_inspect = "#{own_indent}<Node #{name} (#{definition_name}: {#{definitions.keys.join("|")}} -> #{return_type})>"
+        self_inspect = "#{own_indent}<Node #{name} #{skipped? ? "(skipped)" : ""}(#{definition_name}: {#{definitions.keys.join("|")}} -> #{return_type})>"
         if children.any?
           self_inspect << " {\n#{children.values.map { |n| n.inspect(indent + 2)}.join("\n")}\n#{own_indent}}"
         end

data/lib/graphql/internal_representation/rewrite.rb

@@ -24,7 +24,7 @@ module GraphQL
         # 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
+        # [[Nodes::Directive ...]] directive affecting the current scope
         @parent_directives = []
       end
 
@@ -55,6 +55,7 @@ module GraphQL
               name: node_name,
               definition_name: ast_node.name,
               parent: parent_node,
+              included: false, # may be set to true on leaving the node
             )
           end
           object_type = context.parent_type_definition.unwrap
@@ -64,20 +65,21 @@ module GraphQL
         }
 
         visitor[Nodes::InlineFragment].enter << -> (ast_node, prev_ast_node) {
-          @parent_directives.push([])
+          @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?
-            @parent_directives.last << Node.new(
+            directive_irep_node = Node.new(
               name: ast_node.name,
               definition_name: ast_node.name,
               ast_node: ast_node,
-              definitions: [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)
           end
         }
 
@@ -88,6 +90,7 @@ module GraphQL
             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)
@@ -117,8 +120,9 @@ module GraphQL
           # 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
+          applicable_directives = pop_applicable_directives(@parent_directives)
+          spread_node.included ||= GraphQL::Execution::DirectiveChecks.include?(applicable_directives, context.query)
+          spread_node.directives.merge(applicable_directives)
         }
 
         visitor[Nodes::FragmentDefinition].leave << -> (ast_node, prev_ast_node) {
@@ -139,8 +143,9 @@ module GraphQL
           # 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
+          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::Document].leave << -> (ast_node, prev_ast_node) {
@@ -149,12 +154,14 @@ module GraphQL
           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) }
+              # 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, rejected_spread_nodes.first.directives)
+              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)
@@ -166,27 +173,66 @@ module GraphQL
 
       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)
+      # 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.children.each do |name, child_node|
-          deep_merge_child(parent_node, name, child_node, directives)
+          deep_merge_child(parent_node, name, child_node, included)
         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
+      # 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, name, node, extra_included)
+        child_node = parent_node.children[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.children[name] = node.dup
+        end
+
         child_node.definitions.merge!(node.definitions)
+
+        child_node.included = next_included
+
+
+
         node.children.each do |merge_child_name, merge_child_node|
-          deep_merge_child(child_node, merge_child_name, merge_child_node, [])
+          deep_merge_child(child_node, merge_child_name, merge_child_node, node.included)
         end
-        child_node.directives.merge(extra_directives)
       end
 
       # return true if node or _any_ children have a fragment spread
       def any_fragment_spreads?(node)
         node.spreads.any? || node.children.any? { |name, node| any_fragment_spreads?(node) }
       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
+        end
+        own_directives
+      end
+
+
+      # It's an array, but can be identified with `is_a?`
+      class InlineFragmentDirectives
+        extend Forwardable
+        def initialize
+          @storage = []
+        end
+
+        def_delegators :@storage, :push, :+
+      end
     end
   end
 end

data/lib/graphql/language/generation.rb

@@ -21,7 +21,9 @@ module GraphQL
         when Nodes::Argument
           "#{node.name}: #{generate(node.value)}"
         when Nodes::Directive
-          "@#{node.name}(#{node.arguments.map { |a| generate(a) }.join(", ")})"
+          out = "@#{node.name}"
+          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
+          out
         when Nodes::Enum
           "#{node.name}"
         when Nodes::Field
@@ -77,34 +79,46 @@ module GraphQL
           out << "  subscription: #{node.subscription}\n" if node.subscription
           out << "}"
         when Nodes::ScalarTypeDefinition
-          "scalar #{node.name}"
+          out = "scalar #{node.name}"
+          out << generate_directives(node.directives)
         when Nodes::ObjectTypeDefinition
           out = "type #{node.name}"
+          out << generate_directives(node.directives)
           out << " implements " << node.interfaces.join(", ") unless node.interfaces.empty?
           out << generate_field_definitions(node.fields)
         when Nodes::InputValueDefinition
           out = "#{node.name}: #{generate(node.type)}"
           out << " = #{generate(node.default_value)}" unless node.default_value.nil?
-          out
+          out << generate_directives(node.directives)
         when Nodes::FieldDefinition
           out = node.name.dup
           unless node.arguments.empty?
             out << "(" << node.arguments.map{ |arg| generate(arg) }.join(", ") << ")"
           end
           out << ": #{generate(node.type)}"
+          out << generate_directives(node.directives)
         when Nodes::InterfaceTypeDefinition
           out = "interface #{node.name}"
+          out << generate_directives(node.directives)
           out << generate_field_definitions(node.fields)
         when Nodes::UnionTypeDefinition
-          "union #{node.name} = " + node.types.join(" | ")
+          out = "union #{node.name}"
+          out << generate_directives(node.directives)
+          out << " = " + node.types.join(" | ")
         when Nodes::EnumTypeDefinition
-          out = "enum #{node.name} {\n"
+          out = "enum #{node.name}#{generate_directives(node.directives)} {\n"
           node.values.each do |value|
-            out << "  #{value}\n"
+            out << generate(value)
           end
           out << "}"
+        when Nodes::EnumValueDefinition
+          out = "  #{node.name}"
+          out << generate_directives(node.directives)
+          out << "\n"
         when Nodes::InputObjectTypeDefinition
-          out = "input #{node.name} {\n"
+          out = "input #{node.name}"
+          out << generate_directives(node.directives)
+          out << " {\n"
           node.fields.each do |field|
             out << "  #{generate(field)}\n"
           end
@@ -116,7 +130,7 @@ module GraphQL
         when Array
           "[#{node.map { |v| generate(v) }.join(", ")}]"
         when Hash
-          "{ #{node.map { |k, v| "#{k}: #{generate(v)}" }.join(", ")} }"
+          "{#{node.map { |k, v| "#{k}: #{generate(v)}" }.join(", ")}}"
         else
           raise TypeError
         end