Merge branch 'fix-connections' into field-extensions-1.9

Author: rmosolgo

lib/graphql/schema/field.rb

@@ -388,9 +388,6 @@ def resolve_field(obj, args, ctx)
             if @resolve_proc
               # Might be nil, still want to call the func in that case
               @resolve_proc.call(inner_obj, args, ctx)
-            elsif @resolver_class
-              singleton_inst = @resolver_class.new(object: inner_obj, context: query_ctx)
-              public_send_field(singleton_inst, args, ctx)
             else
               public_send_field(after_obj, args, ctx)
             end
@@ -463,6 +460,13 @@ def public_send_field(obj, graphql_args, field_ctx)
 
         query_ctx = field_ctx.query.context
         with_extensions(obj, ruby_kwargs, query_ctx) do |extended_obj, extended_args|
+          if @resolver_class
+            if extended_obj.is_a?(GraphQL::Schema::Object)
+              extended_obj = extended_obj.object
+            end
+            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
+          end
+
           if extended_args.any?
             extended_obj.public_send(@method_sym, **extended_args)
           else

lib/graphql/schema/relay_classic_mutation.rb

@@ -25,20 +25,14 @@ class RelayClassicMutation < GraphQL::Schema::Mutation
       # Relay classic default:
       null(true)
 
-      # Override {GraphQL::Schema::Mutation#resolve_mutation} to
+      # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
-      def resolve_mutation(**kwargs)
+      def resolve_with_support(**kwargs)
         # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
         kwargs.delete(:client_mutation_id)
-        if kwargs.any?
-          resolve(**kwargs)
-        else
-          resolve
-        end
+        super
       end
 
-      resolve_method(:resolve_mutation)
-
       class << self
         # The base class for generated input object types
         # @param new_class [Class] The base class to use for generating input object definitions

lib/graphql/schema/resolver.rb

@@ -74,7 +74,6 @@ def resolve_with_support(**args)
               else
                 authorized?
               end
-              authorized?(loaded_args)
               context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
                 # If the `authorized?` returned two values, `false, early_return`,
                 # then use the early return value instead of continuing
@@ -325,8 +324,7 @@ def type_expr
         # @see {GraphQL::Schema::Argument#initialize} for the signature
         def argument(name, type, *rest, loads: nil, **kwargs, &block)
           if loads
-            arg_keyword = name.to_s.sub(/_id$/, "").to_sym
-            kwargs[:as] = arg_keyword
+            arg_keyword = kwargs[:as] ||= name.to_s.sub(/_id$/, "").to_sym
             own_arguments_loads_as_type[arg_keyword] = loads
           end
           arg_defn = super(name, type, *rest, **kwargs, &block)

spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -70,6 +70,12 @@
       assert_equal "August Greene", res["data"]["renameEnsemble"]["ensemble"]["name"]
     end
 
+    it "uses the `as:` name when loading" do
+      band_query_str = query_str.sub("renameEnsemble", "renameEnsembleAsBand")
+      res = Jazz::Schema.execute(band_query_str, variables: { id: "Ensemble/Robert Glasper Experiment", newName: "August Greene"})
+      assert_equal "August Greene", res["data"]["renameEnsembleAsBand"]["ensemble"]["name"]
+    end
+
     it "returns an error instead when the ID resolves to nil" do
       res = Jazz::Schema.execute(query_str, variables: {
         id: "Ensemble/Nonexistant Name",

spec/graphql/schema/resolver_spec.rb

@@ -194,26 +194,26 @@ def resolve(int:)
 
     class PrepResolver10 < BaseResolver
       argument :int1, Integer, required: true
-      argument :int2, Integer, required: true
+      argument :int2, Integer, required: true, as: :integer_2
       type Integer, null: true
-      def authorized?(int1:, int2:)
-        if int1 + int2 > context[:max_int]
+      def authorized?(int1:, integer_2:)
+        if int1 + integer_2 > context[:max_int]
           raise GraphQL::ExecutionError, "Inputs too big"
-        elsif context[:min_int] && (int1 + int2 < context[:min_int])
+        elsif context[:min_int] && (int1 + integer_2 < context[:min_int])
           false
         else
           true
         end
       end
 
-      def resolve(int1:, int2:)
-        int1 + int2
+      def resolve(int1:, integer_2:)
+        int1 + integer_2
       end
     end
 
     class PrepResolver11 < PrepResolver10
-      def authorized?(int1:, int2:)
-        LazyBlock.new { super(int1: int1 * 2, int2: int2) }
+      def authorized?(int1:, integer_2:)
+        LazyBlock.new { super(int1: int1 * 2, integer_2: integer_2) }
       end
     end
 
@@ -242,6 +242,17 @@ def authorized?(int1:, int2:)
       end
     end
 
+    class PrepResolver14 < GraphQL::Schema::RelayClassicMutation
+      field :number, Integer, null: false
+
+      def authorized?
+        true
+      end
+
+      def resolve
+        { number: 1 }
+      end
+    end
 
     class Query < GraphQL::Schema::Object
       class CustomField < GraphQL::Schema::Field
@@ -278,6 +289,7 @@ def resolve_field(*args)
       field :prep_resolver_11, resolver: PrepResolver11
       field :prep_resolver_12, resolver: PrepResolver12
       field :prep_resolver_13, resolver: PrepResolver13
+      field :prep_resolver_14, resolver: PrepResolver14
     end
 
     class Schema < GraphQL::Schema
@@ -442,6 +454,11 @@ def add_error_assertions(field_name, description)
           assert_equal 11, res["data"]["prepResolver10"]
         end
 
+        it "uses the argument name provided in `as:`" do
+          res = exec_query("{ prepResolver10(int1: 5, int2: 6) }", context: { max_int: 90 })
+          assert_equal 11, res["data"]["prepResolver10"]
+        end
+
         it "can return a lazy object" do
           # This is too big because it's modified in the overridden authorized? hook:
           res = exec_query("{ prepResolver11(int1: 3, int2: 5) }", context: { max_int: 9 })
@@ -478,6 +495,11 @@ def add_error_assertions(field_name, description)
           res = exec_query(str, context: { max_int: 100, min_int: 20 })
           assert_equal({ "prepResolver10" => nil, "prepResolver11" => nil }, res["data"])
         end
+
+        it "works with no arguments for RelayClassicMutation" do
+          res = exec_query("{ prepResolver14(input: {}) { number } }")
+          assert_equal 1, res["data"]["prepResolver14"]["number"]
+        end
       end
     end
 

spec/integration/rails/graphql/relay/connection_resolve_spec.rb

@@ -53,6 +53,22 @@
     end
   end
 
+  describe "when a resolver is used" do
+    it "returns the items with the correct parent" do
+      resolver_query_str = <<-GRAPHQL
+        {
+          rebels {
+            shipsByResolver {
+              parentClassName
+            }
+          }
+        }
+        GRAPHQL
+      result = star_wars_query(resolver_query_str)
+      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["shipsByResolver"]["parentClassName"]
+    end
+  end
+
   describe "when nil is returned" do
     it "becomes null" do
       result = star_wars_query(query_string, { "name" => "null" })

spec/support/jazz.rb

@@ -488,6 +488,14 @@ def resolve(ensemble:, new_name:)
     end
   end
 
+  class RenameEnsembleAsBand < RenameEnsemble
+    argument :ensemble_id, ID, required: true, loads: Ensemble, as: :band
+
+    def resolve(band:, new_name:)
+      super(ensemble: band, new_name: new_name)
+    end
+  end
+
   class Mutation < BaseObject
     field :add_ensemble, Ensemble, null: false do
       argument :input, EnsembleInput, required: true
@@ -496,6 +504,7 @@ class Mutation < BaseObject
     field :add_instrument, mutation: AddInstrument
     field :add_sitar, mutation: AddSitar
     field :rename_ensemble, mutation: RenameEnsemble
+    field :rename_ensemble_as_band, mutation: RenameEnsembleAsBand
 
     def add_ensemble(input:)
       ens = Models::Ensemble.new(input.name)

spec/support/star_wars/schema.rb

@@ -108,6 +108,14 @@ def parent_class_name
     end
   end
 
+  class ShipsByResolver < GraphQL::Schema::Resolver
+    type ShipConnectionWithParentType, null: false
+
+    def resolve
+      object.ships.map { |ship_id| StarWars::DATA["Ship"][ship_id] }
+    end
+  end
+
   class Faction < GraphQL::Schema::Object
     implements GraphQL::Relay::Node.interface
 
@@ -117,6 +125,8 @@ class Faction < GraphQL::Schema::Object
       argument :name_includes, String, required: false
     end
 
+    field :shipsByResolver, resolver: ShipsByResolver, connection: true
+
     def ships(name_includes: nil)
       all_ships = object.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
       if name_includes