Merge pull request rmosolgo#331 from rmosolgo/arg-type-info

feat(Query::Arguments) preserve underlying definitions with argument values

Author: Robert Mosolgo

lib/graphql/query/arguments.rb

@@ -11,15 +11,16 @@ def initialize(values, argument_definitions:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           string_key = inner_key.to_s
           arg_defn = argument_definitions[string_key]
-          memo[string_key] = wrap_value(inner_value, arg_defn.type)
+          arg_value = wrap_value(inner_value, arg_defn.type)
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
           memo
         end
       end
 
       # @param key [String, Symbol] name or index of value to access
       # @return [Object] the argument at that key
       def [](key)
-        @argument_values[key.to_s]
+        @argument_values.fetch(key.to_s, NULL_ARGUMENT_VALUE).value
       end
 
       # @param key [String, Symbol] name of value to access
@@ -36,8 +37,28 @@ def to_h
 
       def_delegators :string_key_values, :keys, :values, :each
 
+      # Access each key, value and type for the arguments in this set.
+      # @yield [argument_value] The {ArgumentValue} for each argument
+      # @yieldparam argument_value [ArgumentValue]
+      def each_value
+        @argument_values.each_value do |argument_value|
+          yield(argument_value)
+        end
+      end
+
       private
 
+      class ArgumentValue
+        attr_reader :key, :value, :definition
+        def initialize(key, value, definition)
+          @key = key
+          @value = value
+          @definition = definition
+        end
+      end
+
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil)
+
       def wrap_value(value, arg_defn_type)
         case value
         when Array

spec/graphql/query/arguments_spec.rb

@@ -45,6 +45,37 @@
     assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
   end
 
+  it "yields key, value, and arg_defnition" do
+    type_info = []
+    arguments.each_value do |arg_value|
+      value = arg_value.value.is_a?(GraphQL::Query::Arguments) ? arg_value.value.to_h : arg_value.value
+      type_info << [arg_value.key, value, arg_value.definition.type.unwrap.name]
+    end
+    expected_type_info =[
+      ["a", 1, "Int"],
+      ["b", 2, "Int"],
+      ["c", { d: 3, e: 4 }, "TestInput1"],
+    ]
+    assert_equal expected_type_info, type_info
+  end
+
+  it "can be copied to a new Arguments instance" do
+    transformed_args = {}
+    types = {}
+    arguments.each_value do |arg_value|
+      transformed_args[arg_value.key.upcase] = arg_value.value
+      types[arg_value.key.upcase] = arg_value.definition
+    end
+
+    new_arguments = GraphQL::Query::Arguments.new(transformed_args, argument_definitions: types)
+    expected_hash = {
+      "A" => 1,
+      "B" => 2,
+      "C" => { d: 3 , e: 4 },
+    }
+    assert_equal expected_hash, new_arguments.to_h
+  end
+
   describe "nested hashes" do
     let(:input_type) {
       test_input_type = GraphQL::InputObjectType.define do
@@ -64,6 +95,19 @@
     end
   end
 
+  describe "#[]" do
+    it "returns the value at that key" do
+      assert_equal 1, arguments["a"]
+      assert_equal 1, arguments[:a]
+      assert arguments["c"].is_a?(GraphQL::Query::Arguments)
+    end
+
+    it "returns nil for missing keys" do
+      assert_equal nil, arguments["z"]
+      assert_equal nil, arguments[7]
+    end
+  end
+
   describe "#key?" do
     let(:arg_values) { [] }
     let(:schema) {