graphql 1.13.12 → 2.0.21

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -29,25 +29,19 @@ module GraphQL
       # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
       def resolve_with_support(**inputs)
-        # Without the interpreter, the inputs are unwrapped by an instrumenter.
-        # But when using the interpreter, no instrumenters are applied.
-        if context.interpreter?
-          input = inputs[:input].to_kwargs
-
-          new_extras = field ? field.extras : []
-          all_extras = self.class.extras + new_extras
-
-          # Transfer these from the top-level hash to the
-          # shortcutted `input:` object
-          all_extras.each do |ext|
-            # It's possible that the `extra` was not passed along by this point,
-            # don't re-add it if it wasn't given here.
-            if inputs.key?(ext)
-              input[ext] = inputs[ext]
-            end
+        input = inputs[:input].to_kwargs
+
+        new_extras = field ? field.extras : []
+        all_extras = self.class.extras + new_extras
+
+        # Transfer these from the top-level hash to the
+        # shortcutted `input:` object
+        all_extras.each do |ext|
+          # It's possible that the `extra` was not passed along by this point,
+          # don't re-add it if it wasn't given here.
+          if inputs.key?(ext)
+            input[ext] = inputs[ext]
           end
-        else
-          input = inputs
         end
 
         if input
@@ -66,26 +60,46 @@ module GraphQL
           super()
         end
 
-        # Again, this is done by an instrumenter when using non-interpreter execution.
-        if context.interpreter?
-          context.schema.after_lazy(return_value) do |return_hash|
-            # It might be an error
-            if return_hash.is_a?(Hash)
-              return_hash[:client_mutation_id] = client_mutation_id
-            end
-            return_hash
+        context.schema.after_lazy(return_value) do |return_hash|
+          # It might be an error
+          if return_hash.is_a?(Hash)
+            return_hash[:client_mutation_id] = client_mutation_id
           end
-        else
-          return_value
+          return_hash
         end
       end
 
       class << self
+        def dummy
+          @dummy ||= begin
+            d = Class.new(GraphQL::Schema::Resolver)
+            d.argument_class(self.argument_class)
+            # TODO make this lazier?
+            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
+            d
+          end
+        end
+
+        def field_arguments(context = GraphQL::Query::NullContext)
+          dummy.arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          dummy.get_argument(name, context)
+        end
+
+        def own_field_arguments
+          dummy.own_arguments
+        end
+
+        def all_field_argument_definitions
+          dummy.all_argument_definitions
+        end
 
         # Also apply this argument to the input type:
-        def argument(*args, **kwargs, &block)
+        def argument(*args, own_argument: false, **kwargs, &block)
           it = input_type # make sure any inherited arguments are already added to it
-          arg = super
+          arg = super(*args, **kwargs, &block)
 
           # This definition might be overriding something inherited;
           # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
@@ -125,15 +139,6 @@ module GraphQL
           @input_type ||= generate_input_type
         end
 
-        # Extend {Schema::Mutation.field_options} to add the `input` argument
-        def field_options
-          sig = super
-          # Arguments were added at the root, but they should be nested
-          sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
-          sig
-        end
-
         private
 
         # Generate the input type for the `input:` argument
@@ -141,11 +146,17 @@ module GraphQL
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
           mutation_args = all_argument_definitions
-          mutation_name = graphql_name
           mutation_class = self
           Class.new(input_object_class) do
-            graphql_name("#{mutation_name}Input")
-            description("Autogenerated input type of #{mutation_name}")
+            class << self
+              def default_graphql_name
+                "#{self.mutation.graphql_name}Input"
+              end
+
+              def description(new_desc = nil)
+                super || "Autogenerated input type of #{self.mutation.graphql_name}"
+              end
+            end
             mutation(mutation_class)
             # these might be inherited:
             mutation_args.each do |arg|

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -20,7 +20,17 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        alias :type :payload_type
+        def type(new_type = nil, null: nil)
+          if new_type
+            payload_type(new_type)
+            if !null.nil?
+              self.null(null)
+            end
+          else
+            super()
+          end
+        end
+
         alias :type_expr :payload_type
 
         def field_class(new_class = nil)
@@ -79,16 +89,16 @@ module GraphQL
         def generate_payload_type
           resolver_name = graphql_name
           resolver_fields = all_field_definitions
-          Class.new(object_class) do
-            graphql_name("#{resolver_name}Payload")
-            description("Autogenerated return type of #{resolver_name}")
-            resolver_fields.each do |f|
-              # Reattach the already-defined field here
-              # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
-              add_field(f, method_conflict_warning: false)
-            end
+          pt = Class.new(object_class)
+          pt.graphql_name("#{resolver_name}Payload")
+          pt.description("Autogenerated return type of #{resolver_name}.")
+          resolver_fields.each do |f|
+            # Reattach the already-defined field here
+            # (The field's `.owner` will still point to the mutation, not the object type, I think)
+            # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+            pt.add_field(f, method_conflict_warning: false)
           end
+          pt
         end
       end
     end

data/lib/graphql/schema/resolver.rb

@@ -15,8 +15,6 @@ module GraphQL
     #
     # A resolver's configuration may be overridden with other keywords in the `field(...)` call.
     #
-    # See the {.field_options} to see how a Resolver becomes a set of field configuration options.
-    #
     # @see {GraphQL::Schema::Mutation} for a concrete subclass of `Resolver`.
     # @see {GraphQL::Function} `Resolver` is a replacement for `GraphQL::Function`
     class Resolver
@@ -75,7 +73,7 @@ module GraphQL
         context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
           if ready_early_return
             if is_ready != false
-              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{ready_early_return.inspect}]"
+              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
             else
               ready_early_return
             end
@@ -210,6 +208,18 @@ module GraphQL
       end
 
       class << self
+        def field_arguments(context = GraphQL::Query::NullContext)
+          arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          get_argument(name, context)
+        end
+
+        def all_field_argument_definitions
+          all_argument_definitions
+        end
+
         # Default `:resolve` set below.
         # @return [Symbol] The method to call on instances of this object to resolve the field
         def resolve_method(new_method = nil)
@@ -242,6 +252,14 @@ module GraphQL
           @null.nil? ? (superclass.respond_to?(:null) ? superclass.null : true) : @null
         end
 
+        def resolver_method(new_method_name = nil)
+          if new_method_name
+            @resolver_method = new_method_name
+          else
+            @resolver_method || :resolve_with_support
+          end
+        end
+
         # Call this method to get the return type of the field,
         # or use it as a configuration method to assign a return type
         # instead of generating one.
@@ -257,8 +275,8 @@ module GraphQL
             @type_expr = new_type
             @null = null
           else
-            if @type_expr
-              GraphQL::Schema::Member::BuildType.parse_type(@type_expr, null: @null)
+            if type_expr
+              GraphQL::Schema::Member::BuildType.parse_type(type_expr, null: self.null)
             elsif superclass.respond_to?(:type)
               superclass.type
             else
@@ -293,8 +311,8 @@ module GraphQL
         # (`nil` means "unlimited max page size".)
         # @param max_page_size [Integer, nil] Set a new value
         # @return [Integer, nil] The `max_page_size` assigned to fields that use this resolver
-        def max_page_size(new_max_page_size = :not_given)
-          if new_max_page_size != :not_given
+        def max_page_size(new_max_page_size = NOT_CONFIGURED)
+          if new_max_page_size != NOT_CONFIGURED
             @max_page_size = new_max_page_size
           elsif defined?(@max_page_size)
             @max_page_size
@@ -307,47 +325,28 @@ module GraphQL
 
         # @return [Boolean] `true` if this resolver or a superclass has an assigned `max_page_size`
         def has_max_page_size?
-          defined?(@max_page_size) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
+          (!!defined?(@max_page_size)) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
         end
 
-        def field_options
-
-          all_args = {}
-          all_argument_definitions.each do |arg|
-            if (prev_entry = all_args[arg.graphql_name])
-              if prev_entry.is_a?(Array)
-                prev_entry << arg
-              else
-                all_args[arg.graphql_name] = [prev_entry, arg]
-              end
-            else
-              all_args[arg.graphql_name] = arg
-            end
-          end
-
-          field_opts = {
-            type: type_expr,
-            description: description,
-            extras: extras,
-            resolver_method: :resolve_with_support,
-            resolver_class: self,
-            arguments: all_args,
-            null: null,
-            complexity: complexity,
-            broadcastable: broadcastable?,
-          }
-
-          # If there aren't any, then the returned array is `[].freeze`,
-          # but passing that along breaks some user code.
-          if (exts = extensions).any?
-            field_opts[:extensions] = exts
-          end
-
-          if has_max_page_size?
-            field_opts[:max_page_size] = max_page_size
+        # Get or set the `default_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited default page size".)
+        # @param default_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `default_page_size` assigned to fields that use this resolver
+        def default_page_size(new_default_page_size = NOT_CONFIGURED)
+          if new_default_page_size != NOT_CONFIGURED
+            @default_page_size = new_default_page_size
+          elsif defined?(@default_page_size)
+            @default_page_size
+          elsif superclass.respond_to?(:default_page_size)
+            superclass.default_page_size
+          else
+            nil
           end
+        end
 
-          field_opts
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `default_page_size`
+        def has_default_page_size?
+          (!!defined?(@default_page_size)) || (superclass.respond_to?(:has_default_page_size?) && superclass.has_default_page_size?)
         end
 
         # A non-normalized type configuration, without `null` applied

data/lib/graphql/schema/scalar.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
@@ -14,20 +13,6 @@ module GraphQL
           val
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::ScalarType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.coerce_result = method(:coerce_result)
-          type_defn.coerce_input = method(:coerce_input)
-          type_defn.metadata[:type_class] = self
-          type_defn.default_scalar = default_scalar
-          type_defn.ast_node = ast_node
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::SCALAR
         end
@@ -55,14 +40,13 @@ module GraphQL
           @default_scalar ||= false
         end
 
-        def validate_non_null_input(value, ctx)
-          result = Query::InputValidationResult.new
+        def validate_non_null_input(value, ctx, max_errors: nil)
           coerced_result = begin
-            ctx.query.with_error_handling do
-              coerce_input(value, ctx)
-            end
+            coerce_input(value, ctx)
           rescue GraphQL::CoercionError => err
             err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
           end
 
           if coerced_result.nil?
@@ -71,11 +55,12 @@ module GraphQL
             else
               " #{GraphQL::Language.serialize(value)}"
             end
-            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
-            result.add_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+            Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          else
+            nil
           end
-          result
         end
       end
     end

data/lib/graphql/schema/subscription.rb

@@ -143,13 +143,6 @@ module GraphQL
       def self.topic_for(arguments:, field:, scope:)
         Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
       end
-
-      # Overriding Resolver#field_options to include subscription_scope
-      def self.field_options
-        super.merge(
-          subscription_scope: subscription_scope
-        )
-      end
     end
   end
 end

data/lib/graphql/schema/timeout.rb

@@ -33,60 +33,56 @@ module GraphQL
     #   end
     #
     class Timeout
-      def self.use(schema, **options)
-        tracer = new(**options)
-        schema.tracer(tracer)
+      def self.use(schema, max_seconds: nil)
+        timeout = self.new(max_seconds: max_seconds)
+        schema.trace_with(self::Trace, timeout: timeout)
       end
 
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
-      def trace(key, data)
-        case key
-        when 'execute_multiplex'
-          data.fetch(:multiplex).queries.each do |query|
-            timeout_duration_s = max_seconds(query)
+      module Trace
+        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        def initialize(timeout:, **rest)
+          @timeout = timeout
+          super
+        end
+
+        def execute_multiplex(multiplex:)
+          multiplex.queries.each do |query|
+            timeout_duration_s = @timeout.max_seconds(query)
             timeout_state = if timeout_duration_s == false
               # if the method returns `false`, don't apply a timeout
               false
             else
               now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-              timeout_at = now + (max_seconds(query) * 1000)
+              timeout_at = now + (timeout_duration_s * 1000)
               {
                 timeout_at: timeout_at,
                 timed_out: false
               }
             end
-            query.context.namespace(self.class)[:state] = timeout_state
+            query.context.namespace(@timeout)[:state] = timeout_state
           end
+          super
+        end
 
-          yield
-        when 'execute_field', 'execute_field_lazy'
-          query_context = data[:context] || data[:query].context
-          timeout_state = query_context.namespace(self.class).fetch(:state)
+        def execute_field(query:, field:, **_rest)
+          timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
-            error = if data[:context]
-              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
-            else
-              field = data.fetch(:field)
-              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
-            end
-
+            error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query_context.query)
+              @timeout.handle_timeout(error, query)
             end
 
             error
           else
-            yield
+            super
           end
-        else
-          yield
         end
       end
 
@@ -114,8 +110,8 @@ module GraphQL
       # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field)
-          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        def initialize(field)
+          super("Timeout on #{field.path}")
         end
       end
     end

data/lib/graphql/schema/type_membership.rb

@@ -11,6 +11,9 @@ module GraphQL
       # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
       attr_reader :abstract_type
 
+      # @return [Hash]
+      attr_reader :options
+
       # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
       # or {Schema::Object.implements} (for interfaces).
       #

data/lib/graphql/schema/union.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
@@ -33,21 +32,6 @@ module GraphQL
           type_memberships.map(&:object_type)
         end
 
-        prepend GraphQL::Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::UnionType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.ast_node = ast_node
-          type_defn.type_memberships = type_memberships
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn.metadata[:type_class] = self
-          type_defn
-        end
-
         def type_membership_class(membership_class = nil)
           if membership_class
             @type_membership_class = membership_class
@@ -86,9 +70,18 @@ module GraphQL
         private
 
         def assert_valid_union_member(type_defn)
-          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+          case type_defn
+          when Class
+            if !type_defn.kind.object?
+              raise ArgumentError, "Union possible_types can only be object types (not #{type_defn.kind.name}, #{type_defn.inspect})"
+            end
+          when Module
             # it's an interface type, defined as a module
             raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          when String, GraphQL::Schema::LateBoundType
+            # Ok - assume it will get checked later
+          else
+            raise ArgumentError, "Union possible_types can only be class-based GraphQL types (not #{type_defn.inspect} (#{type_defn.class.name}))."
           end
         end
       end

data/lib/graphql/schema/validator.rb

@@ -102,7 +102,7 @@ module GraphQL
 
       self.all_validators = {}
 
-      include Schema::FindInheritedValue::EmptyObjects
+      include GraphQL::EmptyObjects
 
       class ValidationFailedError < GraphQL::ExecutionError
         attr_reader :errors

data/lib/graphql/schema/warden.rb

@@ -10,7 +10,7 @@ module GraphQL
     # should go through a warden. If you access the schema directly,
     # you may show a client something that it shouldn't be allowed to see.
     #
-    # @example Hidding private fields
+    # @example Hiding private fields
     #   private_members = -> (member, ctx) { member.metadata[:private] }
     #   result = Schema.execute(query_string, except: private_members)
     #
@@ -38,7 +38,9 @@ module GraphQL
     # @api private
     class Warden
       def self.from_context(context)
-        (context.respond_to?(:warden) && context.warden) || PassThruWarden
+        context.warden # this might be a hash which won't respond to this
+      rescue
+        PassThruWarden
       end
 
       # @param visibility_method [Symbol] a Warden method to call for this entry
@@ -55,7 +57,9 @@ module GraphQL
               if visible_item.nil?
                 visible_item = item
               else
-                raise Schema::DuplicateNamesError, "Found two visible definitions for `#{item.path}`: #{visible_item.inspect}, #{item.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: item.path, duplicated_definition_1: visible_item.inspect, duplicated_definition_2: item.inspect
+                )
               end
             end
           end
@@ -78,6 +82,8 @@ module GraphQL
           def visible_type?(type, ctx); type.visible?(ctx); end
           def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
           def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
+          def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
+          def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
@@ -85,13 +91,20 @@ module GraphQL
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
       def initialize(filter, context:, schema:)
-        @schema = schema.interpreter? ? schema : schema.graphql_definition
+        @schema = schema
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
         @query = @schema.query
         @mutation = @schema.mutation
         @subscription = @schema.subscription
         @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
+        # Initialize all ivars to improve object shape consistency:
+        @types = @visible_types = @reachable_types = @visible_parent_fields =
+          @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
+          @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @reachable_type_set =
+            nil
       end
 
       # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
@@ -172,14 +185,20 @@ module GraphQL
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
-      def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
+      def arguments(argument_owner, ctx = nil)
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
         @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        @visible_enum_arrays ||= read_through { |e| e.enum_values(@context) }
+        @visible_enum_arrays ||= read_through { |e|
+          values = e.enum_values(@context)
+          if values.size == 0
+            raise GraphQL::Schema::Enum::MissingValuesError.new(e)
+          end
+          values
+        }
         @visible_enum_arrays[enum_defn]
       end
 
@@ -231,6 +250,13 @@ module GraphQL
         visible?(type_membership)
       end
 
+      def interface_type_memberships(obj_type, _ctx = nil)
+        @type_memberships ||= read_through do |obj_t|
+          obj_t.interface_type_memberships
+        end
+        @type_memberships[obj_type]
+      end
+
       private
 
       def visible_and_reachable_type?(type_defn)
@@ -330,7 +356,7 @@ module GraphQL
       end
 
       def reachable_type_set
-        return @reachable_type_set if defined?(@reachable_type_set)
+        return @reachable_type_set if @reachable_type_set
 
         @reachable_type_set = Set.new
         rt_hash = {}
@@ -362,7 +388,9 @@ module GraphQL
           if @reachable_type_set.add?(type)
             type_by_name = rt_hash[type.graphql_name] ||= type
             if type_by_name != type
-              raise DuplicateNamesError, "Found two visible type definitions for `#{type.graphql_name}`: #{type.inspect}, #{type_by_name.inspect}"
+              raise DuplicateNamesError.new(
+                duplicated_name: type.graphql_name, duplicated_definition_1: type.inspect, duplicated_definition_2: type_by_name.inspect
+              )
             end
             if type.kind.input_object?
               # recurse into visible arguments