graphql 2.0.28 → 2.2.11

data/lib/graphql/schema/field.rb

@@ -138,7 +138,7 @@ module GraphQL
             # As a last ditch, try to force loading the return type:
             type.unwrap.name
           end
-          @connection = return_type_name.end_with?("Connection")
+          @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection"
         else
           @connection
         end
@@ -218,8 +218,8 @@ module GraphQL
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
-      # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, &definition_block)
+      # @param fallback_value [Object] A fallback value if the method is not defined
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -267,6 +267,7 @@ module GraphQL
         @method_sym = method_name.to_sym
         @resolver_method = (resolver_method || name_s).to_sym
         @complexity = complexity
+        @dynamic_introspection = dynamic_introspection
         @return_type_expr = type
         @return_type_null = if !null.nil?
           null
@@ -351,6 +352,8 @@ module GraphQL
         @call_after_define = true
       end
 
+      attr_accessor :dynamic_introspection
+
       # If true, subscription updates with this field can be shared between viewers
       # @return [Boolean, nil]
       # @see GraphQL::Subscriptions::BroadcastAnalyzer
@@ -480,41 +483,24 @@ module GraphQL
             metadata_complexity = 0
             lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
 
-            if (page_info_lookahead = lookahead.selection(:page_info)).selected?
-              metadata_complexity += 1 # pageInfo
-              metadata_complexity += page_info_lookahead.selections.size # subfields
-            end
-
-            if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
-              metadata_complexity += 1
+            lookahead.selections.each do |next_lookahead|
+              # this includes `pageInfo`, `nodes` and `edges` and any custom fields
+              # TODO this doesn't support procs yet -- unlikely to need it.
+              metadata_complexity += next_lookahead.field.complexity
+              if next_lookahead.name != :nodes && next_lookahead.name != :edges
+                # subfields, eg, for pageInfo -- assumes no subselections
+                metadata_complexity += next_lookahead.selections.size
+              end
             end
 
-            nodes_edges_complexity = 0
-            nodes_edges_complexity += 1 if lookahead.selects?(:edges)
-            nodes_edges_complexity += 1 if lookahead.selects?(:nodes)
-
             # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
-            items_complexity = child_complexity - metadata_complexity - nodes_edges_complexity
-            # Add 1 for _this_ field
-            1 + (max_possible_page_size * items_complexity) + metadata_complexity + nodes_edges_complexity
+            items_complexity = child_complexity - metadata_complexity
+            subfields_complexity = (max_possible_page_size * items_complexity) + metadata_complexity
+            # Apply this field's own complexity
+            apply_own_complexity_to(subfields_complexity, query, nodes)
           end
         else
-          defined_complexity = complexity
-          case defined_complexity
-          when Proc
-            arguments = query.arguments_for(nodes.first, self)
-            if arguments.is_a?(GraphQL::ExecutionError)
-              return child_complexity
-            elsif arguments.respond_to?(:keyword_arguments)
-              arguments = arguments.keyword_arguments
-            end
-
-            defined_complexity.call(query.context, arguments, child_complexity)
-          when Numeric
-            defined_complexity + child_complexity
-          else
-            raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})")
-          end
+          apply_own_complexity_to(child_complexity, query, nodes)
         end
       end
 
@@ -659,7 +645,7 @@ module GraphQL
         method_to_call = nil
         method_args = nil
 
-        Schema::Validator.validate!(validators, application_object, query_ctx, args)
+        @own_validators && Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
         query_ctx.query.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
           if is_authorized
@@ -701,7 +687,7 @@ module GraphQL
                   inner_object.dig(*@dig_keys)
                 elsif inner_object.key?(@method_sym)
                   inner_object[@method_sym]
-                elsif inner_object.key?(@method_str)
+                elsif inner_object.key?(@method_str) || !inner_object.default_proc.nil?
                   inner_object[@method_str]
                 elsif @fallback_value != NOT_CONFIGURED
                   @fallback_value
@@ -879,6 +865,24 @@ ERR
           yield(obj, args)
         end
       end
+
+      def apply_own_complexity_to(child_complexity, query, nodes)
+        case (own_complexity = complexity)
+        when Numeric
+          own_complexity + child_complexity
+        when Proc
+          arguments = query.arguments_for(nodes.first, self)
+          if arguments.is_a?(GraphQL::ExecutionError)
+            return child_complexity
+          elsif arguments.respond_to?(:keyword_arguments)
+            arguments = arguments.keyword_arguments
+          end
+
+          own_complexity.call(query.context, arguments, child_complexity)
+        else
+          raise ArgumentError, "Invalid complexity for #{self.path}: #{own_complexity.inspect}"
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/has_single_input_argument.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    module HasSingleInputArgument
+      def resolve_with_support(**inputs)
+        if inputs[:input].is_a?(InputObject)
+          input = inputs[:input].to_kwargs
+        else
+          input = inputs[:input]
+        end
+
+        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
+        end
+
+        if input
+          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+          input_kwargs = input.to_h
+        else
+          # Relay Classic Mutations with no `argument`s
+          # don't require `input:`
+          input_kwargs = {}
+        end
+
+        if input_kwargs.any?
+          super(**input_kwargs)
+        else
+          super()
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        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.instance)
+          dummy.arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
+          dummy.get_argument(name, context)
+        end
+
+        def own_field_arguments
+          dummy.own_arguments
+        end
+
+        def any_field_arguments?
+          dummy.any_arguments?
+        end
+
+        def all_field_argument_definitions
+          dummy.all_argument_definitions
+        end
+
+        # Also apply this argument to the input type:
+        def argument(*args, own_argument: false, **kwargs, &block)
+          it = input_type # make sure any inherited arguments are already added to it
+          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
+          prev_args = it.own_arguments[arg.graphql_name]
+          case prev_args
+          when GraphQL::Schema::Argument
+            if prev_args.owner != self
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          when Array
+            prev_args.reject! { |a| a.owner != self }
+            if prev_args.empty?
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          end
+
+          it.add_argument(arg)
+          arg
+        end
+
+        # The base class for generated input object types
+        # @param new_class [Class] The base class to use for generating input object definitions
+        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
+        def input_object_class(new_class = nil)
+          if new_class
+            @input_object_class = new_class
+          end
+          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
+        end
+
+        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
+        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
+        def input_type(new_input_type = nil)
+          if new_input_type
+            @input_type = new_input_type
+          end
+          @input_type ||= generate_input_type
+        end
+
+        private
+
+        # Generate the input type for the `input:` argument
+        # To customize how input objects are generated, override this method
+        # @return [Class] a subclass of {.input_object_class}
+        def generate_input_type
+          mutation_args = all_argument_definitions
+          mutation_class = self
+          Class.new(input_object_class) do
+            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|
+              add_argument(arg)
+            end
+          end
+        end
+      end
+
+      private
+
+      def authorize_arguments(args, values)
+        # remove the `input` wrapper to match values
+        input_args = args["input"].type.unwrap.arguments(context)
+        super(input_args, values)
+      end
+    end
+  end
+end

data/lib/graphql/schema/input_object.rb

@@ -79,7 +79,7 @@ module GraphQL
       end
 
       def self.one_of?
-        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+        false # Re-defined when `OneOf` is added
       end
 
       def unwrap_value(value)
@@ -145,7 +145,7 @@ module GraphQL
         end
 
         # @api private
-        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
+        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object."
 
         def validate_non_null_input(input, ctx, max_errors: nil)
           warden = ctx.warden

data/lib/graphql/schema/interface.rb

@@ -20,6 +20,15 @@ module GraphQL
         # - Added as class methods to this interface
         # - Added as class methods to all child interfaces
         def definition_methods(&block)
+          # Use an instance variable to tell whether it's been included previously or not;
+          # You can't use constant detection because constants are brought into scope
+          # by `include`, which has already happened at this point.
+          if !defined?(@_definition_methods)
+            defn_methods_module = Module.new
+            @_definition_methods = defn_methods_module
+            const_set(:DefinitionMethods, defn_methods_module)
+            extend(self::DefinitionMethods)
+          end
           self::DefinitionMethods.module_eval(&block)
         end
 
@@ -47,20 +56,11 @@ module GraphQL
 
             child_class.type_membership_class(self.type_membership_class)
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:DefinitionMethods)
+              if ancestor.const_defined?(:DefinitionMethods) && ancestor != child_class
                 child_class.extend(ancestor::DefinitionMethods)
               end
             end
 
-            # Use an instance variable to tell whether it's been included previously or not;
-            # You can't use constant detection because constants are brought into scope
-            # by `include`, which has already happened at this point.
-            if !child_class.instance_variable_defined?(:@_definition_methods)
-              defn_methods_module = Module.new
-              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
-              child_class.const_set(:DefinitionMethods, defn_methods_module)
-              child_class.extend(child_class::DefinitionMethods)
-            end
             child_class.introspection(introspection)
             child_class.description(description)
             # If interfaces are mixed into each other, only define this class once
@@ -69,7 +69,11 @@ module GraphQL
             end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
+            backtrace_line = caller_locations(0, 10).find do |location|
+              location.base_label == "implements" &&
+                location.path.end_with?("schema/member/has_interfaces.rb")
+            end
+
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end

data/lib/graphql/schema/introspection_system.rb

@@ -39,7 +39,9 @@ module GraphQL
             entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
             entry_point_fields
           end
+        @entry_point_fields.each { |k, v| v.dynamic_introspection = true }
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+        @dynamic_fields.each { |k, v| v.dynamic_introspection = true }
       end
 
       def entry_points

data/lib/graphql/schema/loader.rb

@@ -176,7 +176,6 @@ module GraphQL
             while (of_type = unwrapped_field_hash["ofType"])
               unwrapped_field_hash = of_type
             end
-            type_name = unwrapped_field_hash["name"]
 
             type_defn.field(
               field_hash["name"],
@@ -186,7 +185,6 @@ module GraphQL
               null: true,
               camelize: false,
               connection_extension: nil,
-              connection: type_name.end_with?("Connection"),
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)

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

@@ -102,7 +102,8 @@ module GraphQL
         def default_graphql_name
           @default_graphql_name ||= begin
             raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-            -name.split("::").last.sub(/Type\Z/, "")
+            g_name = -name.split("::").last
+            g_name.end_with?("Type") ? g_name.sub(/Type\Z/, "") : g_name
           end
         end
 

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

@@ -109,7 +109,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments(context = GraphQL::Query::NullContext)
+        def arguments(context = GraphQL::Query::NullContext.instance)
           if own_arguments.any?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
@@ -122,6 +122,10 @@ module GraphQL
           own_arguments_that_apply || own_arguments
         end
 
+        def any_arguments?
+          own_arguments.any?
+        end
+
         module ClassConfigured
           def inherited(child_class)
             super
@@ -129,7 +133,7 @@ module GraphQL
           end
 
           module InheritedArguments
-            def arguments(context = GraphQL::Query::NullContext)
+            def arguments(context = GraphQL::Query::NullContext.instance)
               own_arguments = super
               inherited_arguments = superclass.arguments(context)
 
@@ -145,6 +149,10 @@ module GraphQL
               end
             end
 
+            def any_arguments?
+              super || superclass.any_arguments?
+            end
+
             def all_argument_definitions
               all_defns = {}
               ancestors.reverse_each do |ancestor|
@@ -158,7 +166,7 @@ module GraphQL
             end
 
 
-            def get_argument(argument_name, context = GraphQL::Query::NullContext)
+            def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
               warden = Warden.from_context(context)
               for ancestor in ancestors
                 if ancestor.respond_to?(:own_arguments) &&
@@ -173,9 +181,9 @@ module GraphQL
         end
 
         module FieldConfigured
-          def arguments(context = GraphQL::Query::NullContext)
+          def arguments(context = GraphQL::Query::NullContext.instance)
             own_arguments = super
-            if defined?(@resolver_class) && @resolver_class
+            if @resolver_class
               inherited_arguments = @resolver_class.field_arguments(context)
               if own_arguments.any?
                 if inherited_arguments.any?
@@ -191,8 +199,12 @@ module GraphQL
             end
           end
 
+          def any_arguments?
+            super || (@resolver_class && @resolver_class.any_field_arguments?)
+          end
+
           def all_argument_definitions
-            if defined?(@resolver_class) && @resolver_class
+            if @resolver_class
               all_defns = {}
               @resolver_class.all_field_argument_definitions.each do |arg_defn|
                 key = arg_defn.graphql_name
@@ -224,7 +236,7 @@ module GraphQL
         end
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name, context = GraphQL::Query::NullContext)
+        def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
           if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
             visible_arg
@@ -367,41 +379,52 @@ module GraphQL
           def authorize_application_object(argument, id, context, loaded_application_object)
             context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
-                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                load_application_object_failed(err)
+                err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                application_object = load_application_object_failed(err)
               end
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
-              maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
-                if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
-                  application_object_type, application_object = resolve_type_result
-                else
-                  application_object_type = resolve_type_result
-                  # application_object is already assigned
-                end
-                possible_object_types = context.warden.possible_types(argument.loads)
-                if !possible_object_types.include?(application_object_type)
-                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                  load_application_object_failed(err)
-                else
-                  # This object was loaded successfully
-                  # and resolved to the right type,
-                  # now apply the `.authorized?` class method if there is one
-                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
-                    if authed
-                      application_object
-                    else
-                      err = GraphQL::UnauthorizedError.new(
-                        object: application_object,
-                        type: application_object_type,
-                        context: context,
-                      )
-                      if self.respond_to?(:unauthorized_object)
-                        err.set_backtrace(caller)
-                        unauthorized_object(err)
+              if application_object.nil?
+                nil
+              else
+                maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
+                context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+                  if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+                    application_object_type, application_object = resolve_type_result
+                  else
+                    application_object_type = resolve_type_result
+                    # application_object is already assigned
+                  end
+
+                  if !(
+                      context.warden.possible_types(argument.loads).include?(application_object_type) ||
+                      context.warden.loadable?(argument.loads, context)
+                    )
+                    err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                    application_object = load_application_object_failed(err)
+                  end
+
+                  if application_object.nil?
+                    nil
+                  else
+                    # This object was loaded successfully
+                    # and resolved to the right type,
+                    # now apply the `.authorized?` class method if there is one
+                    context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
                       else
-                        raise err
+                        err = GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: application_object_type,
+                          context: context,
+                        )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   end

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

@@ -97,7 +97,7 @@ module GraphQL
         end
 
         module InterfaceMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) &&
@@ -110,7 +110,7 @@ module GraphQL
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
@@ -130,22 +130,25 @@ module GraphQL
         end
 
         module ObjectMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
-            for ancestor in ancestors
+            ancs = ancestors
+            i = 0
+            while (ancestor = ancs[i])
               if ancestor.respond_to?(:own_fields) &&
                   visible_interface_implementation?(ancestor, context, warden) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
                   (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
                 return f
               end
+              i += 1
             end
             nil
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields