graphql 1.6.4 → 1.6.5

data/lib/graphql/execution/multiplex.rb

@@ -35,17 +35,18 @@ module GraphQL
       end
 
       class << self
-        def run_all(schema, query_options, *rest)
+        def run_all(schema, query_options, *args)
           queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
-          run_queries(schema, queries, *rest)
+          run_queries(schema, queries, *args)
         end
 
         # @param schema [GraphQL::Schema]
         # @param queries [Array<GraphQL::Query>]
         # @param context [Hash]
-        # @param max_complexity [Integer]
+        # @param max_complexity [Integer, nil]
         # @return [Array<Hash>] One result per query
-        def run_queries(schema, queries, context: {}, max_complexity: nil)
+        def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
+
           if has_custom_strategy?(schema)
             if queries.length != 1
               raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
@@ -161,7 +162,7 @@ module GraphQL
           end
 
           multiplex_analyzers = schema.multiplex_analyzers
-          if max_complexity ||= schema.max_complexity
+          if max_complexity
             multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
           end
 

data/lib/graphql/input_object_type.rb

@@ -105,6 +105,11 @@ module GraphQL
       warden = ctx.warden
       result = GraphQL::Query::InputValidationResult.new
 
+      if input.is_a?(Array)
+        result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+        return result
+      end
+
       # We're not actually _using_ the coerced result, we're just
       # using these methods to make sure that the object will
       # behave like a hash below, when we call `each` on it.
@@ -121,7 +126,6 @@ module GraphQL
         end
       end
 
-
       visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
 
       # Items in the input that are unexpected

data/lib/graphql/interface_type.rb

@@ -23,14 +23,15 @@ module GraphQL
   #   end
   #
   class InterfaceType < GraphQL::BaseType
-    accepts_definitions :fields, field: GraphQL::Define::AssignObjectField
+    accepts_definitions :fields, :resolve_type, field: GraphQL::Define::AssignObjectField
 
-    attr_accessor :fields
-    ensure_defined :fields
+    attr_accessor :fields, :resolve_type_proc
+    ensure_defined :fields, :resolve_type_proc, :resolve_type
 
     def initialize
       super
       @fields = {}
+      @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
@@ -42,6 +43,14 @@ module GraphQL
       GraphQL::TypeKinds::INTERFACE
     end
 
+    def resolve_type(value, ctx)
+      ctx.query.resolve_type(self, value)
+    end
+
+    def resolve_type=(resolve_type_callable)
+      @resolve_type_proc = resolve_type_callable
+    end
+
     # @return [GraphQL::Field] The defined field for `field_name`
     def get_field(field_name)
       fields[field_name]

data/lib/graphql/query.rb

@@ -27,7 +27,10 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :context, :root_value, :warden, :provided_variables, :operation_name
+    attr_reader :schema, :context, :root_value, :warden, :provided_variables
+
+    # @return [nil, String] The operation name provided by client or the one inferred from the document. Used to determine which operation to run.
+    attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
     attr_accessor :validate
@@ -74,7 +77,13 @@ module GraphQL
       @query_string = query_string || query
       @document = document
 
-      @resolved_types_cache = Hash.new { |h, k| h[k] = @schema.resolve_type(k, @context) }
+      # A two-layer cache of type resolution:
+      # { abstract_type => { value => resolved_type } }
+      @resolved_types_cache = Hash.new do |h1, k1|
+        h1[k1] = Hash.new do |h2, k2|
+          h2[k2] = @schema.resolve_type(k1, k2, @context)
+        end
+      end
 
       @arguments_cache = ArgumentsCache.build(self)
 
@@ -184,11 +193,17 @@ module GraphQL
 
     def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
 
+    # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
     # @see {#possible_types} to apply filtering from `only` / `except`
-    def resolve_type(value)
-      @resolved_types_cache[value]
+    def resolve_type(abstract_type, value = :__undefined__)
+      if value.is_a?(Symbol) && value == :__undefined__
+        # Old method signature
+        value = abstract_type
+        abstract_type = nil
+      end
+      @resolved_types_cache[abstract_type][value]
     end
 
     def mutation?
@@ -250,7 +265,8 @@ module GraphQL
       elsif parse_error
         # This will be handled later
       else
-        raise ArgumentError, "a query string or document is required"
+        parse_error = GraphQL::ExecutionError.new("No query string was present")
+        @context.add_error(parse_error)
       end
 
       # Trying to execute a document

data/lib/graphql/query/context.rb

@@ -87,6 +87,17 @@ module GraphQL
         GraphQL::Execution::Execute::SKIP
       end
 
+      # Add error at query-level.
+      # @param error [GraphQL::ExecutionError] an execution error
+      # @return [void]
+      def add_error(error)
+        if !error.is_a?(ExecutionError)
+          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        end
+        errors << error
+        nil
+      end
+
       class FieldResolutionContext
         extend GraphQL::Delegate
 

data/lib/graphql/schema.rb

@@ -4,15 +4,13 @@ require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
-require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
-require "graphql/schema/reduce_types"
 require "graphql/schema/timeout_middleware"
+require "graphql/schema/traversal"
 require "graphql/schema/type_expression"
-require "graphql/schema/type_map"
 require "graphql/schema/unique_within_type"
 require "graphql/schema/validation"
 require "graphql/schema/warden"
@@ -128,6 +126,7 @@ module GraphQL
       @mutation_execution_strategy = self.class.default_execution_strategy
       @subscription_execution_strategy = self.class.default_execution_strategy
       @default_mask = GraphQL::Schema::NullMask
+      @rebuilding_artifacts = false
     end
 
     def initialize_copy(other)
@@ -185,15 +184,15 @@ module GraphQL
     def define(**kwargs, &block)
       super
       ensure_defined
-      build_types_map
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
       validation_error && raise(NotImplementedError, validation_error)
-      build_instrumented_field_map
+      rebuild_artifacts
+
       @definition_error = nil
       nil
     rescue StandardError => err
-      if @raise_definition_error
+      if @raise_definition_error || err.is_a?(CyclicalDefinitionError)
         raise
       else
         # Raise this error _later_ to avoid messing with Rails constant loading
@@ -209,14 +208,17 @@ module GraphQL
     def instrument(instrumentation_type, instrumenter)
       @instrumenters[instrumentation_type] << instrumenter
       if instrumentation_type == :field
-        build_instrumented_field_map
+        rebuild_artifacts
       end
     end
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
     def types
-      @types ||= build_types_map
+      @types ||= begin
+        rebuild_artifacts
+        @types
+      end
     end
 
     # Execute a query on itself. Raises an error if the schema definition is invalid.
@@ -226,7 +228,8 @@ module GraphQL
       if query_str
         kwargs[:query] = query_str
       end
-      all_results = multiplex([kwargs])
+      # Since we're running one query, don't run a multiplex-level complexity analyzer
+      all_results = multiplex([kwargs], max_complexity: nil)
       all_results[0]
     end
 
@@ -248,9 +251,9 @@ module GraphQL
     # @param queries [Array<Hash>] Keyword arguments for each query
     # @param context [Hash] Multiplex-level context
     # @return [Array<Hash>] One result for each query in the input
-    def multiplex(*args)
+    def multiplex(queries, **kwargs)
       with_definition_error_check {
-        GraphQL::Execution::Multiplex.run_all(self, *args)
+        GraphQL::Execution::Multiplex.run_all(self, queries, **kwargs)
       }
     end
 
@@ -271,7 +274,7 @@ module GraphQL
           raise "Unexpected parent_type: #{parent_type}"
         end
 
-        defined_field = @instrumented_field_map.get(parent_type_name, field_name)
+        defined_field = @instrumented_field_map[parent_type_name][field_name]
         if defined_field
           defined_field
         elsif field_name == "__typename"
@@ -289,7 +292,7 @@ module GraphQL
     # Fields for this type, after instrumentation is applied
     # @return [Hash<String, GraphQL::Field>]
     def get_fields(type)
-      @instrumented_field_map.get_all(type.name)
+      @instrumented_field_map[type.name]
     end
 
     def type_from_ast(ast_node)
@@ -335,15 +338,29 @@ module GraphQL
     # Determine the GraphQL type for a given object.
     # This is required for unions and interfaces (including Relay's `Node` interface)
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
+    # @param type [GraphQL::UnionType, GraphQL:InterfaceType] the abstract type which is being resolved
     # @param object [Any] An application object which GraphQL is currently resolving on
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
-    def resolve_type(object, ctx)
-      if @resolve_type_proc.nil?
-        raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (obj, ctx) -> { ... }` inside `Schema.define`.")
+    def resolve_type(type, object, ctx = :__undefined__)
+      if ctx == :__undefined__
+        # Old method signature
+        ctx = object
+        object = type
+        type = nil
+      end
+
+      # Prefer a type-local function; fall back to the schema-level function
+      type_proc = type && type.resolve_type_proc
+      type_result = if type_proc
+        type_proc.call(object, ctx)
+      else
+        if @resolve_type_proc.nil?
+          raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (obj, ctx) -> { ... }` inside `Schema.define`.")
+        end
+        @resolve_type_proc.call(type, object, ctx)
       end
 
-      type_result = @resolve_type_proc.call(object, ctx)
       if type_result.nil?
         nil
       elsif !type_result.is_a?(GraphQL::BaseType)
@@ -355,7 +372,8 @@ module GraphQL
     end
 
     def resolve_type=(new_resolve_type_proc)
-      @resolve_type_proc = new_resolve_type_proc
+      callable = GraphQL::BackwardsCompatibility.wrap_arity(new_resolve_type_proc, from: 2, to: 3, last: true, name: "Schema#resolve_type(type, obj, ctx)")
+      @resolve_type_proc = callable
     end
 
     # Fetch an application object by its unique id
@@ -513,17 +531,20 @@ module GraphQL
       GraphQL::Relay::Mutation::Instrumentation,
     ]
 
-    # Apply instrumentation to fields. Relay instrumentation is applied last
-    # so that user-provided instrumentation can wrap user-provided resolve functions,
-    # _then_ Relay helpers can wrap the returned objects.
-    def build_instrumented_field_map
-      all_instrumenters = @instrumenters[:field] + BUILT_IN_INSTRUMENTERS + @instrumenters[:field_after_built_ins]
-      @instrumented_field_map = InstrumentedFieldMap.new(self, all_instrumenters)
+    def rebuild_artifacts
+      if @rebuilding_artifacts
+        raise CyclicalDefinitionError, "Part of the schema build process re-triggered the schema build process, causing an infinite loop. Avoid using Schema#types, Schema#possible_types, and Schema#get_field during schema build."
+      else
+        @rebuilding_artifacts = true
+        traversal = Traversal.new(self)
+        @types = traversal.type_map
+        @instrumented_field_map = traversal.instrumented_field_map
+      end
+    ensure
+      @rebuilding_artifacts = false
     end
 
-    def build_types_map
-      all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
-      @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
+    class CyclicalDefinitionError < GraphQL::Error
     end
 
     def with_definition_error_check

data/lib/graphql/schema/build_from_definition.rb

@@ -110,7 +110,7 @@ module GraphQL
           schema
         end
 
-        NullResolveType = ->(obj, ctx) {
+        NullResolveType = ->(type, obj, ctx) {
           raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
         }
 

data/lib/graphql/schema/build_from_definition/resolve_map.rb

@@ -46,8 +46,8 @@ module GraphQL
 
           # Check the normalized hash, not the user input:
           if @resolve_hash.key?("resolve_type")
-            define_singleton_method :resolve_type do |type, ctx|
-              @resolve_hash.fetch("resolve_type").call(type, ctx)
+            define_singleton_method :resolve_type do |type, obj, ctx|
+              @resolve_hash.fetch("resolve_type").call(type, obj, ctx)
             end
           end
         end

data/lib/graphql/schema/loader.rb

@@ -33,7 +33,7 @@ module GraphQL
         Schema.define(**kargs, raise_definition_error: true)
       end
 
-      NullResolveType = ->(obj, ctx) {
+      NullResolveType = ->(type, obj, ctx) {
         raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
       }
 

data/lib/graphql/schema/traversal.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Visit the members of this schema and build up artifacts for runtime.
+    # @api private
+    class Traversal
+      # @return [Hash<String => GraphQL::BaseType]
+      attr_reader :type_map
+
+      # @return [Hash<String => Hash<String => GraphQL::Field>>]
+      attr_reader :instrumented_field_map
+
+      # @param schema [GraphQL::Schema]
+      def initialize(schema, introspection: true)
+        @schema = schema
+        @introspection = introspection
+        @field_instrumenters =
+          schema.instrumenters[:field] +
+            Schema::BUILT_IN_INSTRUMENTERS +
+            schema.instrumenters[:field_after_built_ins]
+
+        @type_map = {}
+        @instrumented_field_map = Hash.new { |h, k| h[k] = {} }
+        visit(schema, nil)
+      end
+
+      private
+
+      def visit(member, context_description)
+        case member
+        when GraphQL::Schema
+          # Find the starting points, then visit them
+          visit_roots = [member.query, member.mutation, member.subscription]
+          if @introspection
+            visit_roots << GraphQL::Introspection::SchemaType
+          end
+          visit_roots.concat(member.orphan_types)
+          visit_roots.compact!
+          visit_roots.each { |t| visit(t, t.name) }
+        when GraphQL::BaseType
+          type_defn = member.unwrap
+          prev_type = @type_map[type_defn.name]
+          # Continue to visit this type if it's the first time we've seen it:
+          if prev_type.nil?
+            validate_type(type_defn, context_description)
+            @type_map[type_defn.name] = type_defn
+            case type_defn
+            when GraphQL::ObjectType
+              type_defn.interfaces.each { |i| visit(i, "Interface on #{type_defn.name}") }
+              visit_fields(type_defn)
+            when GraphQL::InterfaceType
+              visit_fields(type_defn)
+            when GraphQL::UnionType
+              type_defn.possible_types.each { |t| visit(t, "Possible type for #{type_defn.name}") }
+            when GraphQL::InputObjectType
+              type_defn.arguments.each do |name, arg|
+                visit(arg.type, "Input field #{type_defn.name}.#{name}")
+              end
+            end
+          elsif !prev_type.equal?(type_defn)
+            # If the previous entry in the map isn't the same object we just found, raise.
+            raise("Duplicate type definition found for name '#{type_defn.name}'")
+          end
+        else
+          message = "Unexpected schema traversal member: #{member} (#{member.class.name})"
+          raise GraphQL::Schema::InvalidTypeError.new(message)
+        end
+      end
+
+      def visit_fields(type_defn)
+        type_defn.all_fields.each do |field_defn|
+          instrumented_field_defn = @field_instrumenters.reduce(field_defn) do |defn, inst|
+            inst.instrument(type_defn, defn)
+          end
+          @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
+          visit(instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
+          instrumented_field_defn.arguments.each do |name, arg|
+            visit(arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
+          end
+        end
+      end
+
+      def validate_type(member, context_description)
+        error_message = GraphQL::Schema::Validation.validate(member)
+        if error_message
+          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
+        end
+      end
+    end
+  end
+end