refactor(Execution) isolate some execution helpers

Author: rmosolgo

lib/graphql.rb

@@ -70,3 +70,4 @@ def self.parse_with_racc(string)
 require "graphql/static_validation"
 require "graphql/version"
 require "graphql/relay"
+require "graphql/execution"

lib/graphql/analysis/query_complexity.rb

@@ -32,11 +32,11 @@ def call(memo, visit_type, irep_node)
             memo[:complexities_on_type].push(TypeComplexity.new)
           else
             type_complexities = memo[:complexities_on_type].pop
-            own_complexity = if GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
+            own_complexity = if GraphQL::Execution::DirectiveChecks.skip?(irep_node, memo[:query])
+              0
+            else
               child_complexity = type_complexities.max_possible_complexity
               get_complexity(irep_node, memo[:query], child_complexity)
-            else
-              0
             end
             memo[:complexities_on_type].last.merge(irep_node.definitions, own_complexity)
           end

lib/graphql/analysis/query_depth.rb

@@ -29,13 +29,13 @@ def call(memo, visit_type, irep_node)
               memo[:skip_current_scope] = true
             elsif memo[:skip_current_scope]
               # we're inside an introspection query
-            elsif GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
+            elsif GraphQL::Execution::DirectiveChecks.include?(irep_node, memo[:query])
               memo[:current_depth] += 1
             end
           else
             if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
               memo[:skip_current_scope] = false
-            elsif GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
+            elsif GraphQL::Execution::DirectiveChecks.include?(irep_node, memo[:query])
               if memo[:max_depth] < memo[:current_depth]
                 memo[:max_depth] = memo[:current_depth]
               end

lib/graphql/execution.rb

@@ -0,0 +1,2 @@
+require "graphql/execution/directive_checks"
+require "graphql/execution/typecast"

lib/graphql/execution/directive_checks.rb

@@ -0,0 +1,32 @@
+module GraphQL
+  module Execution
+    # Boolean checks for how an AST node's directives should
+    # influence its execution
+    module DirectiveChecks
+      SKIP = "skip"
+      INCLUDE = "include"
+
+      module_function
+
+      # 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
+      end
+
+      # @return [Boolean] Should this node be included in the query?
+      def include?(irep_node, query)
+        !skip?(irep_node, query)
+      end
+    end
+  end
+end

lib/graphql/execution/typecast.rb

@@ -0,0 +1,33 @@
+module GraphQL
+  module Execution
+    # GraphQL object `{value, type}` can be cast to `other_type` when:
+    # - `type == other_type`
+    # - `type` is a union and it resolves `value` to `other_type`
+    # - `other_type` is a union and `type` is a member
+    # - `type` is an interface and it resolves `value` to `other_type`
+    # - `other_type` is an interface and `type` implements that interface
+    module Typecast
+      # While `value` is exposed by GraphQL as an instance of `current_type`,
+      # should it _also_ be treated as an instance of `potential_type`?
+      #
+      # This is used for checking whether fragments apply to an object.
+      #
+      # @return [Boolean] Can `value` be evaluated as a `potential_type`?
+      def self.compatible?(value, current_type, potential_type, query_ctx)
+        if potential_type == current_type
+          true
+        elsif current_type.kind.union?
+          current_type.resolve_type(value, query_ctx) == potential_type
+        elsif potential_type.kind.union?
+          potential_type.include?(current_type)
+        elsif current_type.kind.interface?
+          current_type.resolve_type(value, query_ctx) == potential_type
+        elsif potential_type.kind.interface?
+          current_type.interfaces.include?(potential_type)
+        else
+          false
+        end
+      end
+    end
+  end
+end

lib/graphql/query.rb

@@ -1,10 +1,8 @@
 require "graphql/query/arguments"
 require "graphql/query/context"
-require "graphql/query/directive_resolution"
 require "graphql/query/executor"
 require "graphql/query/literal_input"
 require "graphql/query/serial_execution"
-require "graphql/query/type_resolver"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
 require "graphql/query/variable_validation_error"

lib/graphql/query/directive_resolution.rb

@@ -13,7 +13,7 @@ def initialize(target, type, irep_node, execution_context)
 
         def result
           irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if included_by_directives?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
+            if GraphQL::Execution::DirectiveChecks.include?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
               field_result = execution_context.strategy.field_resolution.new(
                 irep_node,
                 type,
@@ -27,13 +27,9 @@ def result
 
         private
 
-        def included_by_directives?(irep_node, query)
-          GraphQL::Query::DirectiveResolution.include_node?(irep_node, query)
-        end
-
         def applies_to_type?(irep_node, type, target)
           irep_node.definitions.any? { |child_type, field_defn|
-            GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
+            GraphQL::Execution::Typecast.compatible?(target, child_type, type, execution_context.query.context)
           }
         end
       end