graphql 1.9.7 → 1.9.8

data/lib/graphql/schema/argument.rb

@@ -24,6 +24,11 @@ module GraphQL
       # @return [Class, Module, nil] If this argument should load an application object, this is the type of object to load
       attr_reader :loads
 
+      # @return [Boolean] true if a resolver defined this argument
+      def from_resolver?
+        @from_resolver
+      end
+
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
@@ -33,7 +38,9 @@ module GraphQL
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+      # @param from_resolver [Boolean] if true, a Resolver class defined this argument
+      # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, &definition_block)
         arg_name ||= name
         name_str = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
         @name = name_str.freeze
@@ -46,6 +53,9 @@ module GraphQL
         @loads = loads
         @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
         @prepare = prepare
+        @ast_node = ast_node
+        @from_resolver = from_resolver
+        @method_access = method_access
 
         if definition_block
           if definition_block.arity == 1
@@ -94,6 +104,7 @@ module GraphQL
         argument.description = @description
         argument.metadata[:type_class] = self
         argument.as = @as
+        argument.method_access = @method_access
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end

data/lib/graphql/schema/build_from_definition.rb

@@ -232,6 +232,7 @@ module GraphQL
               name: input_argument.name,
               type: type_resolver.call(input_argument.type),
               description: input_argument.description,
+              method_access: false,
               **kwargs,
             )
 
@@ -269,6 +270,7 @@ module GraphQL
               name: directive_argument.name,
               type: type_resolver.call(directive_argument.type),
               description: directive_argument.description,
+              method_access: false,
               **kwargs,
             )
 
@@ -306,6 +308,7 @@ module GraphQL
                 name: argument.name,
                 description: argument.description,
                 type: type_resolver.call(argument.type),
+                method_access: false,
                 **kwargs,
               )
 

data/lib/graphql/schema/field.rb

@@ -205,7 +205,7 @@ module GraphQL
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
         method_name = method || hash_key || @underscored_name
-        resolver_method ||= @underscored_name
+        resolver_method ||= @underscored_name.to_sym
 
         @method_str = method_name.to_s
         @method_sym = method_name.to_sym
@@ -418,13 +418,10 @@ module GraphQL
       end
 
       def authorized?(object, context)
-        self_auth = if @resolver_class
+        if @resolver_class
+          # The resolver will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
-          true
-        end
-
-        if self_auth
           # Faster than `.any?`
           arguments.each_value do |arg|
             if !arg.authorized?(object, context)
@@ -432,8 +429,6 @@ module GraphQL
             end
           end
           true
-        else
-          false
         end
       end
 

data/lib/graphql/schema/find_inherited_value.rb

@@ -0,0 +1,20 @@
+module GraphQL
+  class Schema
+    module FindInheritedValue
+      private
+
+      def find_inherited_value(method_name, default_value = nil)
+        if self.is_a?(Class)
+          superclass.respond_to?(method_name, true) ? superclass.send(method_name) : default_value
+        else
+          ancestors[1..-1].each do |ancestor|
+            if ancestor.respond_to?(method_name, true)
+              return ancestor.send(method_name)
+            end
+          end
+          default_value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/input_object.rb

@@ -23,7 +23,7 @@ module GraphQL
           ruby_kwargs_key = arg_defn.keyword
           loads = arg_defn.loads
 
-          if @ruby_style_hash.key?(ruby_kwargs_key) && loads
+          if @ruby_style_hash.key?(ruby_kwargs_key) && loads && !arg_defn.from_resolver?
             value = @ruby_style_hash[ruby_kwargs_key]
             @ruby_style_hash[ruby_kwargs_key] = if arg_defn.type.list?
               GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(arg_defn, loads, val) })
@@ -99,8 +99,6 @@ module GraphQL
         attr_accessor :arguments_class
 
         def argument(*args, **kwargs, &block)
-          # Translate `loads:` to `as:` if needed`
-          *args, kwargs = argument_with_loads(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
           method_name = argument_defn.keyword

data/lib/graphql/schema/loader.rb

@@ -148,6 +148,7 @@ module GraphQL
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
+              method_access: false,
               **kwargs
             )
           when "SCALAR"

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/schema/find_inherited_value"
+
 module GraphQL
   class Schema
     class Member
@@ -7,6 +9,8 @@ module GraphQL
       # @api private
       # @see Classes that extend this, eg {GraphQL::Schema::Object}
       module BaseDSLMethods
+        include GraphQL::Schema::FindInheritedValue
+
         # Call this with a new name to override the default name for this schema member; OR
         # call it without an argument to get the name of this schema member
         #
@@ -42,7 +46,7 @@ module GraphQL
           if new_description
             @description = new_description
           else
-            @description || find_inherited_method(:description, nil)
+            @description || find_inherited_value(:description)
           end
         end
 
@@ -51,7 +55,7 @@ module GraphQL
           if !new_introspection.nil?
             @introspection = new_introspection
           else
-            @introspection || find_inherited_method(:introspection, false)
+            @introspection || find_inherited_value(:introspection, false)
           end
         end
 
@@ -76,7 +80,7 @@ module GraphQL
         alias :unwrap :itself
 
         def overridden_graphql_name
-          @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
+          @graphql_name || find_inherited_value(:overridden_graphql_name)
         end
 
         # Creates the default name for a schema member.
@@ -113,21 +117,6 @@ module GraphQL
             true
           end
         end
-
-        private
-
-        def find_inherited_method(method_name, default_value)
-          if self.is_a?(Class)
-            superclass.respond_to?(method_name) ? superclass.public_send(method_name) : default_value
-          else
-            ancestors[1..-1].each do |ancestor|
-              if ancestor.respond_to?(method_name)
-                return ancestor.public_send(method_name)
-              end
-            end
-            default_value
-          end
-        end
       end
     end
   end

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

@@ -13,7 +13,10 @@ module GraphQL
           cls.include(ArgumentObjectLoader)
         end
 
-        def argument_with_loads(*args, **kwargs)
+        # @see {GraphQL::Schema::Argument#initialize} for parameters
+        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
+        def argument(*args, **kwargs, &block)
+          kwargs[:owner] = self
           loads = kwargs[:loads]
           if loads
             name = args[0]
@@ -32,14 +35,6 @@ module GraphQL
 
             kwargs[:as] ||= inferred_arg_name
           end
-
-          return [*args, **kwargs]
-        end
-
-        # @see {GraphQL::Schema::Argument#initialize} for parameters
-        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
-        def argument(*args, **kwargs, &block)
-          kwargs[:owner] = self
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
           add_argument(arg_defn)
         end

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

@@ -38,10 +38,24 @@ module GraphQL
           end
         end
 
+        # A list of field names that we should advise users to pick a different
+        # resolve method name.
+        #
+        # @api private
+        CONFLICT_FIELD_NAMES = Set.new([
+          # GraphQL-Ruby conflicts
+          :context, :object,
+          # Ruby built-ins conflicts
+          :method, :class
+        ])
+
         # Register this field with the class, overriding a previous one if needed.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
+          if CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method)
+            warn "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`)"
+          end
           own_fields[field_defn.name] = field_defn
           nil
         end

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

@@ -8,7 +8,7 @@ module GraphQL
           if new_edge_type_class
             @edge_type_class = new_edge_type_class
           else
-            @edge_type_class || find_inherited_method(:edge_type_class, Types::Relay::BaseEdge)
+            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
           end
         end
 
@@ -16,7 +16,7 @@ module GraphQL
           if new_connection_type_class
             @connection_type_class = new_connection_type_class
           else
-            @connection_type_class || find_inherited_method(:connection_type_class, Types::Relay::BaseConnection)
+            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
           end
         end
 

data/lib/graphql/schema/resolver.rb

@@ -123,12 +123,36 @@ module GraphQL
       # Called after arguments are loaded, but before resolving.
       #
       # Override it to check everything before calling the mutation.
-      # @param args [Hash] The input arguments
+      # @param inputs [Hash] The input arguments
       # @raise [GraphQL::ExecutionError] To add an error to the response
       # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
       # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
-      def authorized?(**args)
-        true
+      def authorized?(**inputs)
+        self.class.arguments.each_value do |argument|
+          arg_keyword = argument.keyword
+          if inputs.key?(arg_keyword) && !(value = inputs[arg_keyword]).nil? && (value != argument.default_value)
+            loads_type = @arguments_loads_as_type[arg_keyword]
+            # If this argument resulted in an object being loaded,
+            # then authorize this loaded object with its own policy.
+            #
+            # But if this argument was "just" a plain argument, like
+            # a boolean, then authorize it based on the mutation.
+            authorization_value = if loads_type
+              value
+            else
+              self
+            end
+
+            arg_auth, err = argument.authorized?(authorization_value, context)
+            if !arg_auth
+              return arg_auth, err
+            else
+              true
+            end
+          else
+            true
+          end
+        end
       end
 
       private
@@ -254,12 +278,11 @@ module GraphQL
         # Add an argument to this field's signature, but
         # also add some preparation hook methods which will be used for this argument
         # @see {GraphQL::Schema::Argument#initialize} for the signature
-        def argument(name, type, *rest, loads: nil, **kwargs, &block)
-          *args, kwargs = argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block)
-          # Short-circuit the InputObject's own `loads:` implementation
+        def argument(*args, **kwargs, &block)
+          loads = kwargs[:loads]
+          # Use `from_resolver: true` to short-circuit the InputObject's own `loads:` implementation
           # so that we can support `#load_{x}` methods below.
-          kwargs.delete(:loads)
-          arg_defn = super(*args, **kwargs)
+          arg_defn = super(*args, from_resolver: true, **kwargs)
           own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
 
           if loads && arg_defn.type.list?

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

@@ -27,7 +27,7 @@ module GraphQL
           if new_class
             @field_class = new_class
           else
-            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
+            @field_class || find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 
@@ -37,8 +37,9 @@ module GraphQL
         def object_class(new_class = nil)
           if new_class
             @object_class = new_class
+          else
+            @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
           end
-          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
         end
 
         private

data/lib/graphql/schema/subscription.rb

@@ -104,7 +104,7 @@ module GraphQL
         elsif defined?(@subscription_scope)
           @subscription_scope
         else
-          find_inherited_method(:subscription_scope, nil)
+          find_inherited_value(:subscription_scope)
         end
       end
 

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -17,7 +17,7 @@ module GraphQL
 
       def assert_required_args(ast_node, defn)
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = defn.arguments.values
+        required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? }
           .map(&:name)
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.9.7"
+  VERSION = "1.9.8"
 end

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -31,6 +31,8 @@ describe GraphQL::Analysis do
     end
   end
 
+  let(:schema) { Class.new(Dummy::Schema) }
+
   describe ".analyze_query" do
     let(:node_counter) {
       ->(memo, visit_type, irep_node) {
@@ -43,7 +45,7 @@ describe GraphQL::Analysis do
     let(:analyzers) { [type_collector, node_counter] }
     let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
     let(:variables) { {} }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
+    let(:query) { GraphQL::Query.new(schema, query_string, variables: variables) }
     let(:query_string) {%|
       {
         cheese(id: 1) {
@@ -58,7 +60,7 @@ describe GraphQL::Analysis do
       let(:analyzers) { [type_collector, conditional_analyzer] }
 
       describe "when analyze? returns false" do
-        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: false }) }
+        let(:query) { GraphQL::Query.new(schema, query_string, variables: variables, context: { analyze: false }) }
 
         it "does not run the analyzer" do
           # Only type_collector ran
@@ -67,7 +69,7 @@ describe GraphQL::Analysis do
       end
 
       describe "when analyze? returns true" do
-        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: true }) }
+        let(:query) { GraphQL::Query.new(schema, query_string, variables: variables, context: { analyze: true }) }
 
         it "it runs the analyzer" do
           # Both analyzers ran
@@ -93,7 +95,7 @@ describe GraphQL::Analysis do
       it "emits traces" do
         traces = TestTracing.with_trace do
           ctx = { tracers: [TestTracing] }
-          Dummy::Schema.execute(query_string, context: ctx)
+          schema.execute(query_string, context: ctx)
         end
 
         # The query_trace is on the list _first_ because it finished first
@@ -119,14 +121,7 @@ describe GraphQL::Analysis do
       let(:variable_accessor) { ->(memo, visit_type, irep_node) { query.variables["cheeseId"] } }
 
       before do
-        @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers << variable_accessor
-      end
-
-      after do
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
+        schema.query_analyzer(variable_accessor)
       end
 
       it "returns an error" do
@@ -213,7 +208,7 @@ describe GraphQL::Analysis do
     let(:flavor_catcher) { FlavorCatcher.new }
     let(:analyzers) { [id_catcher, flavor_catcher] }
     let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
+    let(:query) { GraphQL::Query.new(schema, query_string) }
     let(:query_string) {%|
       {
         cheese(id: 1) {
@@ -222,7 +217,12 @@ describe GraphQL::Analysis do
         }
       }
     |}
-    let(:schema) { Dummy::Schema }
+    let(:schema) do
+      schema = Class.new(Dummy::Schema)
+      schema.query_analyzer(id_catcher)
+      schema.query_analyzer(flavor_catcher)
+      schema
+    end
     let(:result) { schema.execute(query_string) }
     let(:query_string) {%|
       {
@@ -233,17 +233,6 @@ describe GraphQL::Analysis do
       }
     |}
 
-    before do
-      @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers << id_catcher << flavor_catcher
-    end
-
-    after do
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
-    end
-
     it "groups all errors together" do
       data = result["data"]
       errors = result["errors"]