graphql 0.12.1 → 0.13.0

data/lib/graphql/query.rb

@@ -1,98 +1,101 @@
-class GraphQL::Query
-  class OperationNameMissingError < GraphQL::Error
-    def initialize(names)
-      msg = "You must provide an operation name from: #{names.join(", ")}"
-      super(msg)
+module GraphQL
+  # A combination of query string and {Schema} instance which can be reduced to a {#result}.
+  class Query
+    class OperationNameMissingError < GraphQL::ExecutionError
+      def initialize(names)
+        msg = "You must provide an operation name from: #{names.join(", ")}"
+        super(msg)
+      end
     end
-  end
 
-  attr_reader :schema, :document, :context, :fragments, :operations, :debug, :max_depth
+    attr_reader :schema, :document, :context, :fragments, :operations, :debug, :max_depth
 
-  # Prepare query `query_string` on `schema`
-  # @param schema [GraphQL::Schema]
-  # @param query_string [String]
-  # @param context [#[]] an arbitrary hash of values which you can access in {GraphQL::Field#resolve}
-  # @param variables [Hash] values for `$variables` in the query
-  # @param debug [Boolean] if true, errors are raised, if false, errors are put in the `errors` key
-  # @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
-  def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil, max_depth: nil)
-    @schema = schema
-    @debug = debug
-    @max_depth = max_depth || schema.max_depth
-    @context = Context.new(query: self, values: context)
-    @validate = validate
-    @operation_name = operation_name
-    @fragments = {}
-    @operations = {}
-    @provided_variables = variables
-    @document = GraphQL.parse(query_string)
-    @document.definitions.each do |part|
-      if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-        @fragments[part.name] = part
-      elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-        @operations[part.name] = part
+    # Prepare query `query_string` on `schema`
+    # @param schema [GraphQL::Schema]
+    # @param query_string [String]
+    # @param context [#[]] an arbitrary hash of values which you can access in {GraphQL::Field#resolve}
+    # @param variables [Hash] values for `$variables` in the query
+    # @param debug [Boolean] if true, errors are raised, if false, errors are put in the `errors` key
+    # @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
+    def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil, max_depth: nil)
+      @schema = schema
+      @debug = debug
+      @max_depth = max_depth || schema.max_depth
+      @context = Context.new(query: self, values: context)
+      @validate = validate
+      @operation_name = operation_name
+      @fragments = {}
+      @operations = {}
+      @provided_variables = variables
+      @document = GraphQL.parse(query_string)
+      @document.definitions.each do |part|
+        if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+          @fragments[part.name] = part
+        elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+          @operations[part.name] = part
+        end
       end
     end
-  end
 
-  # Get the result for this query, executing it once
-  def result
-    if @validate && validation_errors.any?
-      return { "errors" => validation_errors }
-    end
+    # Get the result for this query, executing it once
+    def result
+      if @validate && validation_errors.any?
+        return { "errors" => validation_errors }
+      end
 
-    @result ||= Executor.new(self).result
-  end
+      @result ||= Executor.new(self).result
+    end
 
 
-  # This is the operation to run for this query.
-  # If more than one operation is present, it must be named at runtime.
-  # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
-  def selected_operation
-    @selected_operation ||= find_operation(@operations, @operation_name)
-  end
+    # This is the operation to run for this query.
+    # If more than one operation is present, it must be named at runtime.
+    # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
+    def selected_operation
+      @selected_operation ||= find_operation(@operations, @operation_name)
+    end
 
-  # Determine the values for variables of this query, using default values
-  # if a value isn't provided at runtime.
-  #
-  # Raises if a non-null variable isn't provided at runtime.
-  # @return [GraphQL::Query::Variables] Variables to apply to this query
-  def variables
-    @variables ||= GraphQL::Query::Variables.new(
-      schema,
-      selected_operation.variables,
-      @provided_variables
-    )
-  end
+    # Determine the values for variables of this query, using default values
+    # if a value isn't provided at runtime.
+    #
+    # Raises if a non-null variable isn't provided at runtime.
+    # @return [GraphQL::Query::Variables] Variables to apply to this query
+    def variables
+      @variables ||= GraphQL::Query::Variables.new(
+        schema,
+        selected_operation.variables,
+        @provided_variables
+      )
+    end
 
-  private
+    private
 
-  def validation_errors
-    @validation_errors ||= schema.static_validator.validate(self)
-  end
+    def validation_errors
+      @validation_errors ||= schema.static_validator.validate(self)
+    end
 
 
-  def find_operation(operations, operation_name)
-    if operations.length == 1
-      operations.values.first
-    elsif operations.length == 0
-      nil
-    elsif !operations.key?(operation_name)
-      raise OperationNameMissingError, operations.keys
-    else
-      operations[operation_name]
+    def find_operation(operations, operation_name)
+      if operations.length == 1
+        operations.values.first
+      elsif operations.length == 0
+        nil
+      elsif !operations.key?(operation_name)
+        raise OperationNameMissingError, operations.keys
+      else
+        operations[operation_name]
+      end
     end
   end
 end
 
-require 'graphql/query/arguments'
-require 'graphql/query/context'
-require 'graphql/query/directive_chain'
-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'
+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"

data/lib/graphql/query/context.rb

@@ -15,12 +15,16 @@ module GraphQL
       # @return [GraphQL::Query] The query whose context this is
       attr_reader :query
 
+      # @return [GraphQL::Schema]
+      attr_reader :schema
+
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
       def initialize(query:, values:)
         @query = query
-        @values = values
+        @schema = query.schema
+        @values = values || {}
         @errors = []
       end
 

data/lib/graphql/query/directive_resolution.rb

@@ -0,0 +1,16 @@
+module GraphQL
+  class Query
+    module DirectiveResolution
+      def self.include_node?(ast_node, query)
+        ast_node.directives.each do |ast_directive|
+          directive = query.schema.directives[ast_directive.name]
+          args = GraphQL::Query::LiteralInput.from_arguments(ast_directive.arguments, directive.arguments, query.variables)
+          if !directive.include?(args)
+            return false
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/graphql/query/executor.rb

@@ -14,12 +14,12 @@ module GraphQL
       def result
         execute
       rescue GraphQL::ExecutionError => err
+        query.context.errors << err
         {"errors" => [err.to_h]}
-      rescue GraphQL::Query::OperationNameMissingError => err
-        {"errors" => [{"message" => err.message}]}
       rescue StandardError => err
+        query.context.errors << err
         query.debug && raise(err)
-        message = "Something went wrong during query execution: #{err}" #\n#{err.backtrace.join("\n  ")}"
+        message = "Internal error" # : #{err} \n#{err.backtrace.join("\n  ")}"
         {"errors" => [{"message" => message}]}
       end
 

data/lib/graphql/query/input_validation_result.rb

@@ -1,22 +1,24 @@
-class GraphQL::Query
-  class InputValidationResult
-    attr_accessor :problems
+module GraphQL
+  class Query
+    class InputValidationResult
+      attr_accessor :problems
 
-    def valid?
-      @problems.nil?
-    end
+      def valid?
+        @problems.nil?
+      end
 
-    def add_problem(explanation, path = nil)
-      @problems ||= []
-      @problems.push({ 'path' => path || [], 'explanation' => explanation })
-    end
+      def add_problem(explanation, path = nil)
+        @problems ||= []
+        @problems.push({ "path" => path || [], "explanation" => explanation })
+      end
 
-    def merge_result!(path, inner_result)
-      return if inner_result.valid?
+      def merge_result!(path, inner_result)
+        return if inner_result.valid?
 
-      inner_result.problems.each do |p|
-        item_path = [path, *p['path']]
-        add_problem(p['explanation'], item_path)
+        inner_result.problems.each do |p|
+          item_path = [path, *p["path"]]
+          add_problem(p["explanation"], item_path)
+        end
       end
     end
   end

data/lib/graphql/query/serial_execution.rb

@@ -32,8 +32,8 @@ module GraphQL
   end
 end
 
-require 'graphql/query/serial_execution/execution_context'
-require 'graphql/query/serial_execution/value_resolution'
-require 'graphql/query/serial_execution/field_resolution'
-require 'graphql/query/serial_execution/operation_resolution'
-require 'graphql/query/serial_execution/selection_resolution'
+require "graphql/query/serial_execution/execution_context"
+require "graphql/query/serial_execution/value_resolution"
+require "graphql/query/serial_execution/field_resolution"
+require "graphql/query/serial_execution/operation_resolution"
+require "graphql/query/serial_execution/selection_resolution"

data/lib/graphql/query/serial_execution/execution_context.rb

@@ -2,15 +2,16 @@ module GraphQL
   class Query
     class SerialExecution
       class ExecutionContext
-        attr_reader :query, :strategy
+        attr_reader :query, :schema, :strategy
 
         def initialize(query, strategy)
           @query = query
+          @schema = query.schema
           @strategy = strategy
         end
 
         def get_type(type)
-          @query.schema.types[type]
+          @schema.types[type]
         end
 
         def get_fragment(name)
@@ -18,7 +19,7 @@ module GraphQL
         end
 
         def get_field(type, name)
-          @query.schema.get_field(type, name)
+          @schema.get_field(type, name)
         end
 
         def add_error(err)

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -41,18 +41,14 @@ module GraphQL
         end
 
         def flatten_inline_fragment(ast_node)
-          chain = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
-            flatten_fragment(ast_node)
-          }
-          chain.result
+          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
+          flatten_fragment(ast_node)
         end
 
         def flatten_fragment_spread(ast_node)
+          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
           ast_fragment_defn = execution_context.get_fragment(ast_node.name)
-          chain = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
-            flatten_fragment(ast_fragment_defn)
-          }
-          chain.result
+          flatten_fragment(ast_fragment_defn)
         end
 
         def flatten_fragment(ast_fragment)
@@ -64,9 +60,13 @@ module GraphQL
         end
 
         def fragment_type_can_apply?(ast_fragment)
-          child_type = execution_context.get_type(ast_fragment.type)
-          resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type).type
-          !resolved_type.nil?
+          if ast_fragment.type.nil?
+            true
+          else
+            child_type = execution_context.get_type(ast_fragment.type)
+            resolved_type = GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
+            !resolved_type.nil?
+          end
         end
 
         def merge_fields(field1, field2)
@@ -89,15 +89,13 @@ module GraphQL
         end
 
         def resolve_field(ast_node)
-          chain = GraphQL::Query::DirectiveChain.new(ast_node, execution_context.query) {
-            execution_context.strategy.field_resolution.new(
-              ast_node,
-              type,
-              target,
-              execution_context
-            ).result
-          }
-          chain.result
+          return {} unless GraphQL::Query::DirectiveResolution.include_node?(ast_node, execution_context.query)
+          execution_context.strategy.field_resolution.new(
+            ast_node,
+            type,
+            target,
+            execution_context
+          ).result
         end
 
         def merge_into_result(memo, selection)
@@ -107,7 +105,7 @@ module GraphQL
             selection.name
           end
 
-          memo[name] = if memo.has_key?(name)
+          memo[name] = if memo.key?(name)
             merge_fields(memo[name], selection)
           else
             selection

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -54,7 +54,7 @@ module GraphQL
 
         class HasPossibleTypeResolution < BaseResolution
           def non_null_result
-            resolved_type = field_type.resolve_type(value)
+            resolved_type = field_type.resolve_type(value, execution_context)
             strategy_class = get_strategy_for_kind(resolved_type.kind)
             inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, ast_field, execution_context)
             inner_strategy.result

data/lib/graphql/query/type_resolver.rb

@@ -1,21 +1,25 @@
-# Given an object, a type name (from the query) and a type object,
-# Return the type that should be used for `object`
-# or Return `nil` if it's a mismatch
-class GraphQL::Query::TypeResolver
-  attr_reader :type
-  def initialize(target, child_type, parent_type)
-    @type = if child_type.nil?
-      nil
-    elsif parent_type.kind.union?
-      parent_type.resolve_type(target)
-    elsif child_type.kind.union? && child_type.include?(parent_type)
-      parent_type
-    elsif child_type.kind.interface?
-      child_type.resolve_type(target)
-    elsif child_type == parent_type
-      parent_type
-    else
-      nil
+module GraphQL
+  class Query
+    # Given an object, a type name (from the query) and a type object,
+    # Return the type that should be used for `object`
+    # or Return `nil` if it's a mismatch
+    class TypeResolver
+      attr_reader :type
+      def initialize(target, child_type, parent_type, query_ctx)
+        @type = if child_type.nil?
+          nil
+        elsif parent_type.kind.union?
+          parent_type.resolve_type(target)
+        elsif child_type.kind.union? && child_type.include?(parent_type)
+          parent_type
+        elsif child_type.kind.interface?
+          child_type.resolve_type(target, query_ctx)
+        elsif child_type == parent_type
+          parent_type
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/graphql/query/variable_validation_error.rb

@@ -1,18 +1,20 @@
-class GraphQL::Query
-  class VariableValidationError < GraphQL::ExecutionError
-    attr_accessor :value, :validation_result
+module GraphQL
+  class Query
+    class VariableValidationError < GraphQL::ExecutionError
+      attr_accessor :value, :validation_result
 
-    def initialize(variable_ast, type, value, validation_result)
-      @value = value
-      @validation_result = validation_result
+      def initialize(variable_ast, type, value, validation_result)
+        @value = value
+        @validation_result = validation_result
 
-      msg = "Variable #{variable_ast.name} of type #{type} was provided invalid value"
-      super(msg)
-      self.ast_node = variable_ast
-    end
+        msg = "Variable #{variable_ast.name} of type #{type} was provided invalid value"
+        super(msg)
+        self.ast_node = variable_ast
+      end
 
-    def to_h
-      super.merge({ 'value' => value, 'problems' => validation_result.problems })
+      def to_h
+        super.merge({ "value" => value, "problems" => validation_result.problems })
+      end
     end
   end
 end