graphql 1.13.17 → 2.0.20

data/lib/graphql/schema/member/has_validators.rb

@@ -18,12 +18,38 @@ module GraphQL
 
         # @return [Array<GraphQL::Schema::Validator>]
         def validators
-          own_validators = @own_validators || EMPTY_ARRAY
-          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
-            inherited_validators + own_validators
-          else
-            own_validators
+          @own_validators || EMPTY_ARRAY
+        end
+
+        module ClassConfigured
+          def inherited(child_cls)
+            super
+            child_cls.extend(ClassValidators)
           end
+
+          module ClassValidators
+            include Schema::FindInheritedValue::EmptyObjects
+
+            def validators
+              inherited_validators = superclass.validators
+              if inherited_validators.any?
+                if @own_validators.nil?
+                  inherited_validators
+                else
+                  inherited_validators + @own_validators
+                end
+              elsif @own_validators.nil?
+                EMPTY_ARRAY
+              else
+                @own_validators
+              end
+            end
+          end
+        end
+
+        def self.extended(child_cls)
+          super
+          child_cls.extend(ClassConfigured)
         end
       end
     end

data/lib/graphql/schema/member/relay_shortcuts.rb

@@ -6,21 +6,40 @@ module GraphQL
       module RelayShortcuts
         def edge_type_class(new_edge_type_class = nil)
           if new_edge_type_class
+            initialize_relay_metadata
             @edge_type_class = new_edge_type_class
           else
-            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
+            # Don't call `ancestor.edge_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_edge_type_class, true) && (etc = ancestor.configured_edge_type_class)
+                return etc
+              end
+            end
+            Types::Relay::BaseEdge
           end
         end
 
         def connection_type_class(new_connection_type_class = nil)
           if new_connection_type_class
+            initialize_relay_metadata
             @connection_type_class = new_connection_type_class
           else
-            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
+            # Don't call `ancestor.connection_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_connection_type_class, true) && (ctc = ancestor.configured_connection_type_class)
+                return ctc
+              end
+            end
+            Types::Relay::BaseConnection
           end
         end
 
         def edge_type
+          initialize_relay_metadata
           @edge_type ||= begin
             edge_name = self.graphql_name + "Edge"
             node_type_class = self
@@ -32,6 +51,7 @@ module GraphQL
         end
 
         def connection_type
+          initialize_relay_metadata
           @connection_type ||= begin
             conn_name = self.graphql_name + "Connection"
             edge_type_class = self.edge_type
@@ -41,6 +61,31 @@ module GraphQL
             end
           end
         end
+
+        protected
+
+        def configured_connection_type_class
+          @connection_type_class
+        end
+
+        def configured_edge_type_class
+          @edge_type_class
+        end
+
+        attr_writer :edge_type, :connection_type, :connection_type_class, :edge_type_class
+
+        private
+
+        # If one of thse values is accessed, initialize all the instance variables to retain
+        # a consistent object shape.
+        def initialize_relay_metadata
+          if !defined?(@connection_type)
+            @connection_type = nil
+            @edge_type = nil
+            @connection_type_class = nil
+            @edge_type_class = nil
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/member/type_system_helpers.rb

@@ -4,6 +4,13 @@ module GraphQL
   class Schema
     class Member
       module TypeSystemHelpers
+        def initialize(*args, &block)
+          super
+          @to_non_null_type ||= nil
+          @to_list_type ||= nil
+        end
+        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
           @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
@@ -32,6 +39,16 @@ module GraphQL
         def kind
           raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
+
+        private
+
+        def inherited(subclass)
+          subclass.class_eval do
+            @to_non_null_type ||= nil
+            @to_list_type ||= nil
+          end
+          super
+        end
       end
     end
   end

data/lib/graphql/schema/member/validates_input.rb

@@ -10,7 +10,7 @@ module GraphQL
 
         def validate_input(val, ctx, max_errors: nil)
           if val.nil?
-            GraphQL::Query::InputValidationResult.new
+            Query::InputValidationResult::VALID
           else
             validate_non_null_input(val, ctx, max_errors: max_errors) || Query::InputValidationResult::VALID
           end

data/lib/graphql/schema/member.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
-require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
-require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_directives'
@@ -14,7 +12,6 @@ require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
 require 'graphql/schema/member/validates_input'
-require "graphql/relay/type_extensions"
 
 module GraphQL
   class Schema
@@ -24,8 +21,6 @@ module GraphQL
     # @api private
     class Member
       include GraphQLTypeNames
-      extend CachedGraphQLDefinition
-      extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
       extend BaseDSLMethods::ConfigurationExtension
       introspection(false)
@@ -41,5 +36,4 @@ end
 
 require 'graphql/schema/member/has_arguments'
 require 'graphql/schema/member/has_fields'
-require 'graphql/schema/member/instrumentation'
 require 'graphql/schema/member/build_type'

data/lib/graphql/schema/mutation.rb

@@ -63,15 +63,6 @@ module GraphQL
       extend GraphQL::Schema::Resolver::HasPayloadType
 
       class << self
-        # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, **kwargs, &block)
-          if args.empty?
-            raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
-          else
-            super
-          end
-        end
-
         def visible?(context)
           true
         end

data/lib/graphql/schema/non_null.rb

@@ -8,13 +8,7 @@ module GraphQL
     class NonNull < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_non_null_type
-      end
-
-       # @return [GraphQL::TypeKinds::NON_NULL]
+      # @return [GraphQL::TypeKinds::NON_NULL]
       def kind
         GraphQL::TypeKinds::NON_NULL
       end

data/lib/graphql/schema/object.rb

@@ -5,7 +5,6 @@ require "graphql/query/null_context"
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Member::HasInterfaces
 
@@ -49,21 +48,19 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
-
-          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
-            context.query.with_error_handling do
-              begin
-                authorized?(object, context)
-              rescue GraphQL::UnauthorizedError => err
-                context.schema.unauthorized_object(err)
-              end
+          maybe_lazy_auth_val = context.query.current_trace.authorized(query: context.query, type: self, object: object) do
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
             end
           end
 
           auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
             GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
+              context.query.current_trace.authorized_lazy(query: context.query, type: self, object: object) do
                 context.schema.sync_lazy(maybe_lazy_auth_val)
               end
             end
@@ -99,48 +96,14 @@ module GraphQL
       class << self
         # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
         # It should help with debugging and bug tracker integrations.
-        def inherited(child_class)
-          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
-          super
-        end
-
-        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
-        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
-        def fields(context = GraphQL::Query::NullContext)
-          all_fields = super
-          # This adds fields from legacy-style interfaces only.
-          # Multi-fields are not supported here.
-          interfaces.each do |int|
-            if int.is_a?(GraphQL::InterfaceType)
-              int_f = {}
-              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-                int_f[name] = field_class.from_options(name, field: legacy_field)
-              end
-              all_fields = int_f.merge(all_fields)
-            end
-          end
-          all_fields
-        end
-
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        # @return [GraphQL::ObjectType]
-        def to_graphql
-          obj_type = GraphQL::ObjectType.new
-          obj_type.name = graphql_name
-          obj_type.description = description
-          obj_type.structural_interface_type_memberships = interface_type_memberships
-          obj_type.introspection = introspection
-          obj_type.mutation = mutation
-          obj_type.ast_node = ast_node
-          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
-            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+        def const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
           end
-
-          obj_type.metadata[:type_class] = self
-
-          obj_type
         end
 
         def kind

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
@@ -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_given)
+          if new_default_page_size != :not_given
+            @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