Merge pull request rmosolgo#1797 from cjoudrey/loads-array

Add support for array of IDs to `loads:` argument

Author: Robert Mosolgo

lib/graphql/schema/resolver.rb

@@ -324,12 +324,32 @@ def type_expr
         # @see {GraphQL::Schema::Argument#initialize} for the signature
         def argument(name, type, *rest, loads: nil, **kwargs, &block)
           if loads
-            arg_keyword = kwargs[:as] ||= name.to_s.sub(/_id$/, "").to_sym
-            own_arguments_loads_as_type[arg_keyword] = loads
+            name_as_string = name.to_s
+
+            inferred_arg_name = case name_as_string
+            when /_id$/
+              name_as_string.sub(/_id$/, "").to_sym
+            when /_ids$/
+              name_as_string.sub(/_ids$/, "")
+                .sub(/([^s])$/, "\\1s")
+                .to_sym
+            else
+              name
+            end
+
+            kwargs[:as] ||= inferred_arg_name
+            own_arguments_loads_as_type[kwargs[:as]] = loads
           end
+
           arg_defn = super(name, type, *rest, **kwargs, &block)
 
-          if loads
+          if loads && arg_defn.type.list?
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def load_#{arg_defn.keyword}(values)
+              GraphQL::Execution::Lazy.all(values.map { |value| load_application_object(:#{arg_defn.keyword}, value) })
+            end
+            RUBY
+          elsif loads
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def load_#{arg_defn.keyword}(value)
               load_application_object(:#{arg_defn.keyword}, value)

spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -52,6 +52,71 @@
     end
   end
 
+  describe "loading multiple application objects" do
+    let(:query_str) {
+      <<-GRAPHQL
+        mutation($ids: [ID!]!) {
+          upvoteEnsembles(input: {ensembleIds: $ids}) {
+            ensembles {
+              id
+            }
+          }
+        }
+      GRAPHQL
+    }
+
+    it "loads arguments as objects of the given type and strips `_ids` suffix off argument name and appends `s`" do
+      res = Jazz::Schema.execute(query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsembles"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "uses the `as:` name when loading" do
+      as_bands_query_str = query_str.sub("upvoteEnsembles", "upvoteEnsemblesAsBands")
+      res = Jazz::Schema.execute(as_bands_query_str, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsemblesAsBands"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "doesn't append `s` to argument names that already end in `s`" do
+      query = <<-GRAPHQL
+        mutation($ids: [ID!]!) {
+          upvoteEnsemblesIds(input: {ensemblesIds: $ids}) {
+            ensembles {
+              id
+            }
+          }
+        }
+      GRAPHQL
+
+      res = Jazz::Schema.execute(query, variables: { ids: ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"]})
+      assert_equal ["Ensemble/Robert Glasper Experiment", "Ensemble/Bela Fleck and the Flecktones"], res["data"]["upvoteEnsemblesIds"]["ensembles"].map { |e| e["id"] }
+    end
+
+    it "returns an error instead when the ID resolves to nil" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        ids: ["Ensemble/Nonexistant Name"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      assert_equal ['No object found for `ensembleIds: "Ensemble/Nonexistant Name"`'], res["errors"].map { |e| e["message"] }
+    end
+
+    it "returns an error instead when the ID resolves to an object of the wrong type" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        ids: ["Instrument/Organ"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      assert_equal ["No object found for `ensembleIds: \"Instrument/Organ\"`"], res["errors"].map { |e| e["message"] }
+    end
+
+    it "raises an authorization error when the type's auth fails" do
+      res = Jazz::Schema.execute(query_str, variables: {
+        ids: ["Ensemble/Spinal Tap"],
+      })
+      assert_nil res["data"].fetch("upvoteEnsembles")
+      # Failed silently
+      refute res.key?("errors")
+    end
+  end
+
   describe "loading application objects" do
     let(:query_str) {
       <<-GRAPHQL

spec/graphql/schema/resolver_spec.rb

@@ -192,6 +192,23 @@ def resolve(int:)
       end
     end
 
+    class PrepResolver9Array < BaseResolver
+      argument :int_ids, [ID], required: true, loads: HasValue, as: :ints
+      # Make sure the lazy object is resolved properly:
+      type [HasValue], null: false
+      def object_from_id(type, id, ctx)
+        # Make sure a lazy object is handled appropriately
+        LazyBlock.new {
+          # Make sure that the right type ends up here
+          id.to_i + type.graphql_name.length
+        }
+      end
+
+      def resolve(ints:)
+        ints.map { |int| int * 3}
+      end
+    end
+
     class PrepResolver10 < BaseResolver
       argument :int1, Integer, required: true
       argument :int2, Integer, required: true, as: :integer_2
@@ -285,6 +302,7 @@ def resolve_field(*args)
       field :prep_resolver_6, resolver: PrepResolver6
       field :prep_resolver_7, resolver: PrepResolver7
       field :prep_resolver_9, resolver: PrepResolver9
+      field :prep_resolver_9_array, resolver: PrepResolver9Array
       field :prep_resolver_10, resolver: PrepResolver10
       field :prep_resolver_11, resolver: PrepResolver11
       field :prep_resolver_12, resolver: PrepResolver12
@@ -509,6 +527,14 @@ def add_error_assertions(field_name, description)
         # (5 + 8) * 3
         assert_equal 39, res["data"]["prepResolver9"]["value"]
       end
+
+      it "supports loading array of ids" do
+        res = exec_query('{ prepResolver9Array(intIds: ["1", "10", "100"]) { value } }')
+        # (1 + 8) * 3
+        # (10 + 8) * 3
+        # (100 + 8) * 3
+        assert_equal [27, 54, 324], res["data"]["prepResolver9Array"].map { |v| v["value"] }
+      end
     end
   end
 end

spec/support/jazz.rb

@@ -488,6 +488,42 @@ def resolve(ensemble:, new_name:)
     end
   end
 
+  class UpvoteEnsembles < GraphQL::Schema::RelayClassicMutation
+    argument :ensemble_ids, [ID], required: true, loads: Ensemble
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(ensembles:)
+      {
+        ensembles: ensembles
+      }
+    end
+  end
+
+  class UpvoteEnsemblesAsBands < GraphQL::Schema::RelayClassicMutation
+    argument :ensemble_ids, [ID], required: true, loads: Ensemble, as: :bands
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(bands:)
+      {
+        ensembles: bands
+      }
+    end
+  end
+
+  class UpvoteEnsemblesIds < GraphQL::Schema::RelayClassicMutation
+    argument :ensembles_ids, [ID], required: true, loads: Ensemble
+
+    field :ensembles, [Ensemble], null: false
+
+    def resolve(ensembles:)
+      {
+        ensembles: ensembles
+      }
+    end
+  end
+
   class RenameEnsembleAsBand < RenameEnsemble
     argument :ensemble_id, ID, required: true, loads: Ensemble, as: :band
 
@@ -504,6 +540,9 @@ class Mutation < BaseObject
     field :add_instrument, mutation: AddInstrument
     field :add_sitar, mutation: AddSitar
     field :rename_ensemble, mutation: RenameEnsemble
+    field :upvote_ensembles, mutation: UpvoteEnsembles
+    field :upvote_ensembles_as_bands, mutation: UpvoteEnsemblesAsBands
+    field :upvote_ensembles_ids, mutation: UpvoteEnsemblesIds
     field :rename_ensemble_as_band, mutation: RenameEnsembleAsBand
 
     def add_ensemble(input:)