graphql 1.0.0 → 1.1.0

data/lib/graphql/object_type.rb

@@ -46,9 +46,11 @@ module GraphQL
     def interfaces
       @clean_interfaces ||= begin
         ensure_defined
-        @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-      rescue
-        @dirty_interfaces
+        if @dirty_interfaces.respond_to?(:map)
+          @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
+        else
+          @dirty_interfaces
+        end
       end
     end
 

data/lib/graphql/query.rb

@@ -17,7 +17,15 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string
+    module NullExcept
+      module_function
+
+      def call(member)
+        false
+      end
+    end
+
+    attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string, :warden
 
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
@@ -28,10 +36,12 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @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: {}, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil)
+    # @param except [<#call(schema_member)>] If provided, objects will be hidden from the schema when `.call(schema_member)` returns truthy
+    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, except: NullExcept)
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
       @schema = schema
+      @warden = GraphQL::Schema::Warden.new(schema, except)
       @max_depth = max_depth || schema.max_depth
       @max_complexity = max_complexity || schema.max_complexity
       @query_analyzers = schema.query_analyzers.dup
@@ -81,16 +91,9 @@ module GraphQL
     # Get the result for this query, executing it once
     def result
       @result ||= begin
-        if !valid?
-          all_errors = validation_errors + analysis_errors
-          if all_errors.any?
-            { "errors" => all_errors.map(&:to_h) }
-          else
-            nil
-          end
-        else
-          Executor.new(self).result
-        end
+        instrumenters = @schema.instrumenters[:query]
+        execution_call = ExecutionCall.new(self, instrumenters)
+        execution_call.call
       end
     end
 
@@ -110,6 +113,7 @@ module GraphQL
       @variables ||= begin
         vars = GraphQL::Query::Variables.new(
           @schema,
+          @warden,
           @ast_variables,
           @provided_variables,
         )
@@ -198,5 +202,37 @@ module GraphQL
         operations[operation_name]
       end
     end
+
+    class ExecutionCall
+      def initialize(query, instrumenters)
+        @query = query
+        @instrumenters = instrumenters
+      end
+
+      # Check if the query is valid, and if it is,
+      # execute it, calling instrumenters along the way
+      # @return [Hash] The GraphQL response
+      def call
+        @instrumenters.each { |i| i.before_query(@query) }
+        result = get_result
+        @instrumenters.each { |i| i.after_query(@query) }
+        result
+      end
+
+      private
+
+      def get_result
+        if !@query.valid?
+          all_errors = @query.validation_errors + @query.analysis_errors
+          if all_errors.any?
+            { "errors" => all_errors.map(&:to_h) }
+          else
+            nil
+          end
+        else
+          Executor.new(@query).result
+        end
+      end
+    end
   end
 end

data/lib/graphql/query/context.rb

@@ -6,7 +6,9 @@ module GraphQL
       attr_accessor :execution_strategy
 
       # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
-      attr_accessor :ast_node
+      def ast_node
+        irep_node.ast_node
+      end
 
       # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
       attr_accessor :irep_node
@@ -20,6 +22,9 @@ module GraphQL
       # @return [GraphQL::Schema]
       attr_reader :schema
 
+      # @return [GraphQL::Schema::Mask::Warden]
+      attr_reader :warden
+
       # 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
@@ -28,6 +33,7 @@ module GraphQL
         @schema = query.schema
         @values = values || {}
         @errors = []
+        @warden = query.warden
       end
 
       # Lookup `key` from the hash passed to {Schema#execute} as `context:`

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

@@ -8,10 +8,11 @@ module GraphQL
           @query = query
           @schema = query.schema
           @strategy = strategy
+          @warden = query.warden
         end
 
-        def get_type(type)
-          @schema.types[type]
+        def get_type(type_name)
+          @warden.get_type(type_name)
         end
 
         def get_fragment(name)
@@ -20,7 +21,11 @@ module GraphQL
 
         def get_field(type, irep_node)
           # fall back for dynamic fields (eg __typename)
-          irep_node.definitions[type] || @schema.get_field(type, irep_node.definition_name) || raise("No field found on #{type.name} for '#{irep_node.definition_name}' (#{irep_node.ast_node.name})")
+          irep_node.definitions[type] || @warden.get_field(type, irep_node.definition_name) || raise("No field found on #{type.name} for '#{irep_node.definition_name}' (#{irep_node.ast_node.name})")
+        end
+
+        def possible_types(type)
+          @warden.possible_types(type)
         end
 
         def add_error(err)

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

@@ -40,10 +40,15 @@ module GraphQL
             end
           end
 
-          strategy_class = GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(field.type.kind)
-          result_strategy = strategy_class.new(raw_value, field.type, target, parent_type, irep_node, execution_context)
           begin
-            result_strategy.result
+            GraphQL::Query::SerialExecution::ValueResolution.resolve(
+              parent_type,
+              field,
+              field.type,
+              raw_value,
+              irep_node,
+              execution_context,
+            )
           rescue GraphQL::InvalidNullError => err
             if field.type.kind.non_null?
               raise(err)
@@ -63,7 +68,6 @@ module GraphQL
           middlewares = execution_context.query.schema.middleware
           query_context = execution_context.query.context
           # setup
-          query_context.ast_node = @irep_node.ast_node
           query_context.irep_node = @irep_node
 
           resolve_arguments = [parent_type, target, field, arguments, query_context]
@@ -84,7 +88,6 @@ module GraphQL
             end
         ensure
           # teardown
-          query_context.ast_node = nil
           query_context.irep_node = nil
           resolve_value
         end

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

@@ -11,12 +11,12 @@ module GraphQL
         end
 
         def result
-          execution_context.strategy.selection_resolution.new(
+          execution_context.strategy.selection_resolution.resolve(
             execution_context.query.root_value,
             target,
             irep_node,
             execution_context
-          ).result
+          )
         rescue GraphQL::InvalidNullError => err
           err.parent_error? || execution_context.add_error(err)
           nil

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

@@ -1,22 +1,13 @@
 module GraphQL
   class Query
     class SerialExecution
-      class SelectionResolution
-        attr_reader :target, :type, :irep_node, :execution_context
-
-        def initialize(target, type, irep_node, execution_context)
-          @target = target
-          @type = type
-          @irep_node = irep_node
-          @execution_context = execution_context
-        end
-
-        def result
+      module SelectionResolution
+        def self.resolve(target, current_type, irep_node, execution_context)
           irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if irep_node.included? && applies_to_type?(irep_node, type)
+            if irep_node.included? && irep_node.definitions.any? { |potential_type, field_defn| GraphQL::Execution::Typecast.compatible?(current_type, potential_type, execution_context.query.context) }
               field_result = execution_context.strategy.field_resolution.new(
                 irep_node,
-                type,
+                current_type,
                 target,
                 execution_context
               ).result
@@ -24,14 +15,6 @@ module GraphQL
             end
           end
         end
-
-        private
-
-        def applies_to_type?(irep_node, current_type)
-          irep_node.definitions.any? { |potential_type, field_defn|
-            GraphQL::Execution::Typecast.compatible?(current_type, potential_type, execution_context.query.context)
-          }
-        end
       end
     end
   end

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

@@ -2,112 +2,72 @@ module GraphQL
   class Query
     class SerialExecution
       module ValueResolution
-        def self.get_strategy_for_kind(kind)
-          TYPE_KIND_STRATEGIES[kind] || raise("No value resolution strategy for #{kind}!")
-        end
-
-        class BaseResolution
-          attr_reader :value, :field_type, :target, :parent_type,
-            :irep_node, :execution_context
-          def initialize(value, field_type, target, parent_type, irep_node, execution_context)
-            @value = value
-            @field_type = field_type
-            @target = target
-            @parent_type = parent_type
-            @irep_node = irep_node
-            @execution_context = execution_context
-          end
-
-          def result
-            if value.nil? || value.is_a?(GraphQL::ExecutionError)
-              nil
+        def self.resolve(parent_type, field_defn, field_type, value, irep_node, execution_context)
+          if value.nil? || value.is_a?(GraphQL::ExecutionError)
+            if field_type.kind.non_null?
+              raise GraphQL::InvalidNullError.new(parent_type.name, field_defn.name, value)
             else
-              non_null_result
-            end
-          end
-
-          def non_null_result
-            raise NotImplementedError, "Should return a value based on initialization params"
-          end
-
-          def get_strategy_for_kind(*args)
-            GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(*args)
-          end
-        end
-
-        class ScalarResolution < BaseResolution
-          # Apply the scalar's defined `coerce_result` method to the value
-          def non_null_result
-            field_type.coerce_result(value)
-          end
-        end
-
-        class ListResolution < BaseResolution
-          # For each item in the list,
-          # Resolve it with the "wrapped" type of this list
-          def non_null_result
-            wrapped_type = field_type.of_type
-            strategy_class = get_strategy_for_kind(wrapped_type.kind)
-            result = value.each_with_index.map do |item, index|
-              irep_node.index = index
-              inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, irep_node, execution_context)
-              inner_strategy.result
-            end
-            irep_node.index = nil
-            result
-          end
-        end
-
-        class HasPossibleTypeResolution < BaseResolution
-          def non_null_result
-            resolved_type = execution_context.schema.resolve_type(value, execution_context.query.context)
-            possible_types = execution_context.schema.possible_types(field_type)
-
-            unless resolved_type.is_a?(GraphQL::ObjectType) && possible_types.include?(resolved_type)
-              raise GraphQL::UnresolvedTypeError.new(irep_node.definition_name, execution_context.schema, field_type, parent_type, resolved_type)
+              nil
             end
+          else
+            case field_type.kind
+            when GraphQL::TypeKinds::SCALAR
+              field_type.coerce_result(value)
+            when GraphQL::TypeKinds::ENUM
+              field_type.coerce_result(value, execution_context.query.warden)
+            when GraphQL::TypeKinds::LIST
+              wrapped_type = field_type.of_type
+              result = value.each_with_index.map do |inner_value, index|
+                irep_node.index = index
+                resolve(
+                  parent_type,
+                  field_defn,
+                  wrapped_type,
+                  inner_value,
+                  irep_node,
+                  execution_context,
+                )
+              end
+              irep_node.index = nil
+              result
+            when GraphQL::TypeKinds::NON_NULL
+              wrapped_type = field_type.of_type
+              resolve(
+                parent_type,
+                field_defn,
+                wrapped_type,
+                value,
+                irep_node,
+                execution_context,
+              )
+            when GraphQL::TypeKinds::OBJECT
+              execution_context.strategy.selection_resolution.resolve(
+                value,
+                field_type,
+                irep_node,
+                execution_context
+              )
+            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
+              resolved_type = execution_context.schema.resolve_type(value, execution_context.query.context)
+              possible_types = execution_context.possible_types(field_type)
 
-            strategy_class = get_strategy_for_kind(resolved_type.kind)
-            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, irep_node, execution_context)
-            inner_strategy.result
-          end
-        end
-
-        class ObjectResolution < BaseResolution
-          # Resolve the selections on this object
-          def non_null_result
-            execution_context.strategy.selection_resolution.new(
-              value,
-              field_type,
-              irep_node,
-              execution_context
-            ).result
-          end
-        end
-
-        class NonNullResolution < BaseResolution
-          # Get the "wrapped" type and resolve the value according to that type
-          def result
-            if value.nil? || value.is_a?(GraphQL::ExecutionError)
-              raise GraphQL::InvalidNullError.new(parent_type.name, irep_node.definition_name, value)
+              if !possible_types.include?(resolved_type)
+                raise GraphQL::UnresolvedTypeError.new(irep_node.definition_name, field_type, parent_type, resolved_type, possible_types)
+              else
+                resolve(
+                  parent_type,
+                  field_defn,
+                  resolved_type,
+                  value,
+                  irep_node,
+                  execution_context,
+                )
+              end
             else
-              wrapped_type = field_type.of_type
-              strategy_class = get_strategy_for_kind(wrapped_type.kind)
-              inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, irep_node, execution_context)
-              inner_strategy.result
+              raise("Unknown type kind: #{field_type.kind}")
             end
           end
         end
-
-        TYPE_KIND_STRATEGIES = {
-          GraphQL::TypeKinds::SCALAR =>     ScalarResolution,
-          GraphQL::TypeKinds::LIST =>       ListResolution,
-          GraphQL::TypeKinds::OBJECT =>     ObjectResolution,
-          GraphQL::TypeKinds::ENUM =>       ScalarResolution,
-          GraphQL::TypeKinds::NON_NULL =>   NonNullResolution,
-          GraphQL::TypeKinds::INTERFACE =>  HasPossibleTypeResolution,
-          GraphQL::TypeKinds::UNION =>      HasPossibleTypeResolution,
-        }
       end
     end
   end

data/lib/graphql/query/variables.rb

@@ -2,11 +2,14 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
+      extend Forwardable
+
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors
 
-      def initialize(schema, ast_variables, provided_variables)
+      def initialize(schema, warden, ast_variables, provided_variables)
         @schema = schema
+        @warden = warden
         @provided_variables = provided_variables
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
@@ -19,6 +22,8 @@ module GraphQL
         @storage.fetch(key)
       end
 
+      def_delegators :@storage, :length
+
       private
 
       # Find the right value for this variable:
@@ -31,7 +36,7 @@ module GraphQL
         default_value = ast_variable.default_value
         provided_value = @provided_variables[variable_name]
 
-        validation_result = variable_type.validate_input(provided_value)
+        validation_result = variable_type.validate_input(provided_value, @warden)
         if !validation_result.valid?
           @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
         elsif provided_value.nil?