graphql 1.12.10 → 1.13.4

data/lib/graphql/schema/input_object.rb

@@ -11,6 +11,14 @@ module GraphQL
 
       include GraphQL::Dig
 
+      # @return [GraphQL::Query::Context] The context for this query
+      attr_reader :context
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      attr_reader :arguments
+
+      # Ruby-like hash behaviors, read-only
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
+
       def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
@@ -23,7 +31,7 @@ module GraphQL
         end
         # Apply prepares, not great to have it duplicated here.
         maybe_lazies = []
-        self.class.arguments.each_value do |arg_defn|
+        self.class.arguments(context).each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
 
           if @ruby_style_hash.key?(ruby_kwargs_key)
@@ -32,11 +40,7 @@ module GraphQL
             # With the interpreter, it's done during `coerce_arguments`
             if loads && !arg_defn.from_resolver? && !context.interpreter?
               value = @ruby_style_hash[ruby_kwargs_key]
-              loaded_value = if arg_defn.type.list?
-                value.map { |val| load_application_object(arg_defn, loads, val, context) }
-              else
-                load_application_object(arg_defn, loads, value, context)
-              end
+              loaded_value = arg_defn.load_and_authorize_value(self, value, context)
               maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
                 overwrite_argument(ruby_kwargs_key, loaded_value)
               end
@@ -54,19 +58,8 @@ module GraphQL
         @maybe_lazies = maybe_lazies
       end
 
-      # @return [GraphQL::Query::Context] The context for this query
-      attr_reader :context
-
-      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
-      attr_reader :arguments
-
-      # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
-
       def to_h
-        @ruby_style_hash.inject({}) do |h, (key, value)|
-          h.merge(key => unwrap_value(value))
-        end
+        unwrap_value(@ruby_style_hash)
       end
 
       def to_hash
@@ -74,11 +67,11 @@ module GraphQL
       end
 
       def prepare
-        if context
-          context.schema.after_any_lazies(@maybe_lazies) do
-            object = context[:current_object]
+        if @context
+          @context.schema.after_any_lazies(@maybe_lazies) do
+            object = @context[:current_object]
             # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
-            Schema::Validator.validate!(self.class.validators, object, context, @ruby_style_hash, as: self.class)
+            Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
             self
           end
         else
@@ -86,13 +79,28 @@ module GraphQL
         end
       end
 
+      def self.authorized?(obj, value, ctx)
+        # Authorize each argument (but this doesn't apply if `prepare` is implemented):
+        if value.is_a?(InputObject)
+          arguments(ctx).each do |_name, input_obj_arg|
+            input_obj_arg = input_obj_arg.type_class
+            if value.key?(input_obj_arg.keyword) &&
+              !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # It didn't early-return false:
+        true
+      end
+
       def unwrap_value(value)
         case value
         when Array
           value.map { |item| unwrap_value(item) }
         when Hash
-          value.inject({}) do |h, (key, value)|
-            h.merge(key => unwrap_value(value))
+          value.reduce({}) do |h, (key, value)|
+            h.merge!(key => unwrap_value(value))
           end
         when InputObject
           value.to_h
@@ -136,8 +144,11 @@ module GraphQL
               self[#{method_name.inspect}]
             end
           RUBY
+          argument_defn
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InputObjectType.new
           type_defn.name = graphql_name
@@ -145,8 +156,8 @@ module GraphQL
           type_defn.metadata[:type_class] = self
           type_defn.mutation = mutation
           type_defn.ast_node = ast_node
-          arguments.each do |name, arg|
-            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
+          all_argument_definitions.each do |arg|
+            type_defn.arguments[arg.graphql_definition(silence_deprecation_warning: true).name] = arg.graphql_definition(silence_deprecation_warning: true) # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class
           self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)
@@ -162,7 +173,6 @@ module GraphQL
         # @api private
         INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
 
-
         def validate_non_null_input(input, ctx)
           result = GraphQL::Query::InputValidationResult.new
 
@@ -180,7 +190,7 @@ module GraphQL
           end
 
           # Inject missing required arguments
-          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
+          missing_required_inputs = self.arguments(ctx).reduce({}) do |m, (argument_name, argument)|
             if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
               m[argument_name] = nil
             end
@@ -231,7 +241,7 @@ module GraphQL
 
           result = {}
 
-          arguments.each do |input_key, input_field_defn|
+          arguments(ctx).each do |input_key, input_field_defn|
             input_value = value[input_key]
             if value.key?(input_key)
               result[input_key] = if input_value.nil?

data/lib/graphql/schema/interface.rb

@@ -16,6 +16,7 @@ module GraphQL
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
         include GraphQL::Schema::Member::HasDirectives
+        include GraphQL::Schema::Member::HasInterfaces
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -57,9 +58,10 @@ module GraphQL
             child_class.extend(Schema::Interface::DefinitionMethods)
 
             child_class.type_membership_class(self.type_membership_class)
-            child_class.own_interfaces << self
-            child_class.interfaces.reverse_each do |interface_defn|
-              child_class.extend(interface_defn::DefinitionMethods)
+            child_class.ancestors.reverse_each do |ancestor|
+              if ancestor.const_defined?(:DefinitionMethods)
+                child_class.extend(ancestor::DefinitionMethods)
+              end
             end
 
             # Use an instance variable to tell whether it's been included previously or not;
@@ -73,16 +75,13 @@ module GraphQL
             end
             child_class.introspection(introspection)
             child_class.description(description)
-            if overridden_graphql_name
-              child_class.graphql_name(overridden_graphql_name)
-            end
             # If interfaces are mixed into each other, only define this class once
             if !child_class.const_defined?(:UnresolvedTypeError, false)
               add_unresolved_type_error(child_class)
             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/object.rb") && line.include?("in `implements'")}
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end
@@ -101,6 +100,8 @@ module GraphQL
           end
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::InterfaceType.new
           type_defn.name = graphql_name
@@ -108,9 +109,9 @@ module GraphQL
           type_defn.orphan_types = orphan_types
           type_defn.type_membership_class = self.type_membership_class
           type_defn.ast_node = ast_node
-          fields.each do |field_name, field_inst|
-            field_defn = field_inst.graphql_definition
-            type_defn.fields[field_defn.name] = field_defn
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
+            type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           type_defn.metadata[:type_class] = self
           if respond_to?(:resolve_type)
@@ -122,16 +123,6 @@ module GraphQL
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
-
-        protected
-
-        def own_interfaces
-          @own_interfaces ||= []
-        end
-
-        def interfaces
-          own_interfaces + (own_interfaces.map { |i| i.own_interfaces }).flatten
-        end
       end
 
       # Extend this _after_ `DefinitionMethods` is defined, so it will be used

data/lib/graphql/schema/introspection_system.rb

@@ -107,7 +107,7 @@ module GraphQL
           dup_type_class(const)
         else
           # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.to_graphql
+          const.deprecated_to_graphql
         end
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared

data/lib/graphql/schema/list.rb

@@ -8,8 +8,10 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_list_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
       end
 
       # @return [GraphQL::TypeKinds::LIST]

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

@@ -85,8 +85,15 @@ module GraphQL
                 define_method(name) do |*args|
                   if args.any?
                     instance_variable_set(ivar_name, args)
+                  else
+                    if (v = instance_variable_get(ivar_name))
+                      v
+                    elsif (ancestor = ancestors.find { |i| i.respond_to?(name) && i != self })
+                      ancestor.public_send(name)
+                    else
+                      nil
+                    end
                   end
-                  instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
                 end
               end
             end
@@ -116,8 +123,13 @@ module GraphQL
         end
 
         module ToGraphQLExtension
-          def to_graphql
-            defn = super
+          def to_graphql(*args, **kwargs)
+
+            defn = if args.empty? && kwargs.empty?
+              super()
+            else
+              super
+            end
             accepts_definition_methods.each do |method_name|
               value = public_send(method_name)
               if !value.nil?

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

@@ -4,10 +4,6 @@ module GraphQL
     class Member
       # @api private
       module BuildType
-        if !String.method_defined?(:match?)
-          using GraphQL::StringMatchBackport
-        end
-
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function
@@ -124,6 +120,7 @@ module GraphQL
         end
 
         def camelize(string)
+          return string if string == '_'
           return string unless string.include?("_")
           camelized = string.split('_').map(&:capitalize).join
           camelized[0] = camelized[0].downcase

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

@@ -11,8 +11,24 @@ module GraphQL
         # A cached result of {.to_graphql}.
         # It's cached here so that user-overridden {.to_graphql} implementations
         # are also cached
-        def graphql_definition
-          @graphql_definition ||= to_graphql
+        def graphql_definition(silence_deprecation_warning: false)
+          @graphql_definition ||= begin
+            unless silence_deprecation_warning
+              message = "Legacy `.graphql_definition` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.graphql_definition` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            deprecated_to_graphql
+          end
+        end
+
+        def deprecated_to_graphql
+          case method(:to_graphql).arity
+          when 0
+            to_graphql
+          else
+            to_graphql(silence_deprecation_warning: true)
+          end
         end
 
         # This is for a common interface with .define-based types
@@ -25,6 +41,17 @@ module GraphQL
           super
           @graphql_definition = nil
         end
+
+        module DeprecatedToGraphQL
+          def to_graphql(silence_deprecation_warning: false)
+            unless silence_deprecation_warning
+              message = "Legacy `.to_graphql` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.to_graphql` to use a class-based definition instead."
+              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
+              GraphQL::Deprecation.warn(message + caller_message)
+            end
+            super()
+          end
+        end
       end
     end
   end

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

@@ -37,6 +37,40 @@ module GraphQL
           end
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
           add_argument(arg_defn)
+
+          if self.is_a?(Class) && !method_defined?(:"load_#{arg_defn.keyword}")
+            method_owner = if self < GraphQL::Schema::InputObject || self < GraphQL::Schema::Directive
+              "self."
+            elsif self < GraphQL::Schema::Resolver
+              ""
+            else
+              raise "Unexpected argument owner: #{self}"
+            end
+            if loads && arg_defn.type.list?
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
+                argument = get_argument("#{arg_defn.graphql_name}")
+                (context || self.context).schema.after_lazy(values) do |values2|
+                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
+                end
+              end
+              RUBY
+            elsif loads
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(value, context = nil)
+                argument = get_argument("#{arg_defn.graphql_name}")
+                load_application_object(argument, value, context || self.context)
+              end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(value, _context = nil)
+                value
+              end
+              RUBY
+            end
+          end
+          arg_defn
         end
 
         # Register this argument with the class.
@@ -44,30 +78,72 @@ module GraphQL
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
           @own_arguments ||= {}
-          own_arguments[arg_defn.name] = arg_defn
+          prev_defn = own_arguments[arg_defn.name]
+          case prev_defn
+          when nil
+            own_arguments[arg_defn.name] = arg_defn
+          when Array
+            prev_defn << arg_defn
+          when GraphQL::Schema::Argument
+            own_arguments[arg_defn.name] = [prev_defn, arg_defn]
+          else
+            raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
+          end
           arg_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : nil)
+        def arguments(context = GraphQL::Query::NullContext)
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments(context) : nil)
           # Local definitions override inherited ones
+          if own_arguments.any?
+            own_arguments_that_apply = {}
+            own_arguments.each do |name, args_entry|
+              if (visible_defn = Warden.visible_entry?(:visible_argument?, args_entry, context))
+                own_arguments_that_apply[visible_defn.graphql_name] = visible_defn
+              end
+            end
+          end
+
           if inherited_arguments
-            inherited_arguments.merge(own_arguments)
+            if own_arguments_that_apply
+              inherited_arguments.merge(own_arguments_that_apply)
+            else
+              inherited_arguments
+            end
           else
-            own_arguments
+            # might be nil if there are actually no arguments
+            own_arguments_that_apply || own_arguments
           end
         end
 
-        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name)
-          a = own_arguments[argument_name]
+        def all_argument_definitions
+          if self.is_a?(Class)
+            all_defns = {}
+            ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_arguments)
+                all_defns.merge!(ancestor.own_arguments)
+              end
+            end
+          else
+            all_defns = own_arguments
+          end
+          all_defns = all_defns.values
+          all_defns.flatten!
+          all_defns
+        end
 
-          if a || !self.is_a?(Class)
-            a
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        def get_argument(argument_name, context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          if !self.is_a?(Class)
+            a = own_arguments[argument_name]
+            a && Warden.visible_entry?(:visible_argument?, a, context, warden)
           else
             for ancestor in ancestors
-              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
+              if ancestor.respond_to?(:own_arguments) &&
+                (a = ancestor.own_arguments[argument_name]) &&
+                (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
                 return a
               end
             end
@@ -91,57 +167,55 @@ module GraphQL
         # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
-          arg_defns = self.arguments
+          arg_defns = self.arguments(context)
           total_args_count = arg_defns.size
 
-          if total_args_count == 0
-            final_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            if block_given?
-              block.call(final_args)
-              nil
+          finished_args = nil
+          prepare_finished_args = -> {
+            if total_args_count == 0
+              finished_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
+              if block_given?
+                block.call(finished_args)
+              end
             else
-              final_args
-            end
-          else
-            finished_args = nil
-            argument_values = {}
-            resolved_args_count = 0
-            raised_error = false
-            arg_defns.each do |arg_name, arg_defn|
-              context.dataloader.append_job do
-                begin
-                  arg_defn.coerce_into_values(parent_object, values, context, argument_values)
-                rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                  raised_error = true
-                  if block_given?
-                    block.call(err)
-                  else
+              argument_values = {}
+              resolved_args_count = 0
+              raised_error = false
+              arg_defns.each do |arg_name, arg_defn|
+                context.dataloader.append_job do
+                  begin
+                    arg_defn.coerce_into_values(parent_object, values, context, argument_values)
+                  rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                    raised_error = true
                     finished_args = err
+                    if block_given?
+                      block.call(finished_args)
+                    end
                   end
-                end
 
-                resolved_args_count += 1
-                if resolved_args_count == total_args_count && !raised_error
-                  finished_args = context.schema.after_any_lazies(argument_values.values) {
-                    GraphQL::Execution::Interpreter::Arguments.new(
-                      argument_values: argument_values,
-                    )
-                  }
-
-                  if block_given?
-                    block.call(finished_args)
+                  resolved_args_count += 1
+                  if resolved_args_count == total_args_count && !raised_error
+                    finished_args = context.schema.after_any_lazies(argument_values.values) {
+                      GraphQL::Execution::Interpreter::Arguments.new(
+                        argument_values: argument_values,
+                      )
+                    }
+                    if block_given?
+                      block.call(finished_args)
+                    end
                   end
                 end
               end
             end
+          }
 
-            if block_given?
-              nil
-            else
-              # This API returns eagerly, gotta run it now
-              context.dataloader.run
-              finished_args
-            end
+          if block_given?
+            prepare_finished_args.call
+            nil
+          else
+            # This API returns eagerly, gotta run it now
+            context.dataloader.run_isolated(&prepare_finished_args)
+            finished_args
           end
         end
 
@@ -159,7 +233,7 @@ module GraphQL
         def arguments_statically_coercible?
           return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
 
-          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
         end
 
         module ArgumentClassAccessor
@@ -186,12 +260,20 @@ module GraphQL
             context.schema.object_from_id(id, context)
           end
 
-          def load_application_object(argument, lookup_as_type, id, context)
+          def load_application_object(argument, id, context)
             # See if any object can be found for this ID
             if id.nil?
               return nil
             end
-            loaded_application_object = object_from_id(lookup_as_type, id, context)
+            object_from_id(argument.loads, id, context)
+          end
+
+          def load_and_authorize_application_object(argument, id, context)
+            loaded_application_object = load_application_object(argument, id, context)
+            authorize_application_object(argument, id, context, loaded_application_object)
+          end
+
+          def authorize_application_object(argument, id, context, loaded_application_object)
             context.schema.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
                 err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
@@ -199,9 +281,9 @@ module GraphQL
               end
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
-              resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+              resolved_application_object_type = context.schema.resolve_type(argument.loads, application_object, context)
               context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
-                possible_object_types = context.warden.possible_types(lookup_as_type)
+                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)
@@ -214,11 +296,17 @@ module GraphQL
                       if authed
                         application_object
                       else
-                        raise GraphQL::UnauthorizedError.new(
+                        err = GraphQL::UnauthorizedError.new(
                           object: application_object,
                           type: class_based_type,
                           context: context,
                         )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   else

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

@@ -7,7 +7,7 @@ module GraphQL
         # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
         def deprecation_reason
           dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
-          dir && dir.arguments[:reason]
+          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
         end
 
         # Set the deprecation reason for this member, or remove it by assigning `nil`