graphql 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e3922b4ba691948512f6936a9ebf5438e468698
-  data.tar.gz: 9162e5e2f437fc323e733a7682dd44dae9bb8cc8
+  metadata.gz: fe097cf7f88ed8a62ed53cc4fb3df2943a7a26e7
+  data.tar.gz: 66c7f5ef3707ffdf91a8e15b5fd94319c6799f6c
 SHA512:
-  metadata.gz: 1c3763c608645843eaffaa81d95e29d019008209b1af2f91a06d35431403114a4b60feebfec3e7659db45b05695e7a4ce3c67012f573ca4e4283ecc12a2186c3
-  data.tar.gz: 08e82e3316840ebaeeb63aee2e73d8909ae863634c00d6eec38e03ba8a2a2038239f1e4ef694af70f952599aafc6d6bd3f1623741ebb0b7d61e3d8f43765c21e
+  metadata.gz: 6f922011419b6a8dcaed84c2088c0323681b27b283881339a021aeee0ae21b3d5d68da6da75dffe317d5db3514a2e0f5b7f9143553d2b3fef4d27ebeb36f45ae
+  data.tar.gz: e109b93bd6d60ef1e57dd09e64260b1fc89aa728c01153ec703bc73e2232ba628df78e8188dba57b98a57b81a214aa750cd6f85c4f364a9db487dec85a8d9ead

data/lib/graphql/field.rb

@@ -130,7 +130,7 @@ module GraphQL
 
     ensure_defined(
       :name, :deprecation_reason, :description, :description=, :property, :hash_key, :mutation, :arguments, :complexity,
-      :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc,
+      :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
       :relay_node_field,
     )

data/lib/graphql/input_object_type.rb

@@ -99,7 +99,9 @@ module GraphQL
           coerced_value = input_field_defn.default_value
         end
 
-        input_values[input_key] = coerced_value if coerced_value || value.key?(input_key)
+        if coerced_value || value.key?(input_key)
+          input_values[input_key] = coerced_value
+        end
       end
 
       GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)

data/lib/graphql/query/literal_input.rb

@@ -3,100 +3,63 @@ module GraphQL
   class Query
     # Turn query string values into something useful for query execution
     class LiteralInput
-      def self.coerce(type, value, variables)
-        if value.is_a?(Language::Nodes::VariableIdentifier)
-          variables[value.name]
-        elsif value.nil?
+      def self.coerce(type, ast_node, variables)
+        case ast_node
+        when nil
           nil
+        when Language::Nodes::VariableIdentifier
+          variables[ast_node.name]
         else
-          LiteralKindCoercers::STRATEGIES.fetch(type.kind).coerce(value, type, variables)
-        end
-      end
-
-      def self.from_arguments(ast_arguments, argument_defns, variables)
-        values_hash = {}
-        argument_defns.each do |arg_name, arg_defn|
-          ast_arg = ast_arguments.find { |ast_arg| ast_arg.name == arg_name }
-          arg_default_value = arg_defn.default_value
-          if ast_arg.nil? && arg_default_value.nil?
-            # If it wasn't in the document,
-            # and there's no provided default,
-            # then don't pass it to the resolve function
-            next
-          else
-            arg_value = nil
-
-            if ast_arg
-              arg_value = coerce(arg_defn.type, ast_arg.value, variables)
-            end
-
-            if arg_value.nil?
-              arg_value = arg_default_value
+          case type
+          when GraphQL::ScalarType
+            type.coerce_input(ast_node)
+          when GraphQL::EnumType
+            type.coerce_input(ast_node.name)
+          when GraphQL::NonNullType
+            LiteralInput.coerce(type.of_type, ast_node, variables)
+          when GraphQL::ListType
+            if ast_node.is_a?(Array)
+              ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
+            else
+              [LiteralInput.coerce(type.of_type, ast_node, variables)]
             end
-
-            values_hash[arg_name] = arg_value
+          when GraphQL::InputObjectType
+            from_arguments(ast_node.arguments, type.arguments, variables)
           end
         end
-        GraphQL::Query::Arguments.new(values_hash, argument_definitions: argument_defns)
       end
 
-      module LiteralKindCoercers
-        module NonNullLiteral
-          def self.coerce(value, type, variables)
-            LiteralInput.coerce(type.of_type, value, variables)
-          end
-        end
-
-        module ListLiteral
-          def self.coerce(value, type, variables)
-            if value.is_a?(Array)
-              value.map{ |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
-            else
-              [LiteralInput.coerce(type.of_type, value, variables)]
-            end
-          end
-        end
+      def self.from_arguments(ast_arguments, argument_defns, variables)
+        values_hash = {}
+        indexed_arguments = ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
 
-        module InputObjectLiteral
-          def self.coerce(value, type, variables)
-            hash = {}
-            value.arguments.each do |arg|
-              field_type = type.arguments[arg.name].type
-              hash[arg.name] = LiteralInput.coerce(field_type, arg.value, variables)
-            end
-            type.input_fields.each do |arg_name, arg_defn|
-              if hash[arg_name].nil?
-                value = LiteralInput.coerce(arg_defn.type, arg_defn.default_value, variables)
-                if !value.nil?
-                  hash[arg_name] = value
-                end
+        argument_defns.each do |arg_name, arg_defn|
+          ast_arg = indexed_arguments[arg_name]
+          # First, check the argument in the AST.
+          # If the value is a variable,
+          # only add a value if the variable is actually present.
+          # Otherwise, coerce the value in the AST and add it.
+          if ast_arg
+            if ast_arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+              if variables.key?(ast_arg.value.name)
+                values_hash[ast_arg.name] = coerce(arg_defn.type, ast_arg.value, variables)
               end
+            else
+              values_hash[ast_arg.name] = coerce(arg_defn.type, ast_arg.value, variables)
             end
-            Arguments.new(hash, argument_definitions: type.arguments)
           end
-        end
 
-        module EnumLiteral
-          def self.coerce(value, type, variables)
-            type.coerce_input(value.name)
+          # Then, the definition for a default value.
+          # If the definition has a default value and
+          # a value wasn't provided from the AST,
+          # then add the default value.
+          if arg_defn.default_value? && !values_hash.key?(arg_name)
+            values_hash[arg_name] = arg_defn.default_value
           end
         end
 
-        module ScalarLiteral
-          def self.coerce(value, type, variables)
-            type.coerce_input(value)
-          end
-        end
-
-        STRATEGIES = {
-          TypeKinds::NON_NULL =>     NonNullLiteral,
-          TypeKinds::LIST =>         ListLiteral,
-          TypeKinds::INPUT_OBJECT => InputObjectLiteral,
-          TypeKinds::ENUM =>         EnumLiteral,
-          TypeKinds::SCALAR =>       ScalarLiteral,
-        }
+        GraphQL::Query::Arguments.new(values_hash, argument_definitions: argument_defns)
       end
-      private_constant :LiteralKindCoercers
     end
   end
 end

data/lib/graphql/version.rb

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

data/spec/graphql/field_spec.rb

@@ -190,4 +190,13 @@ describe GraphQL::Field do
       assert_equal({a: 1, b: 2, c: 3}, int_field_2.metadata)
     end
   end
+
+  describe "#resolve_proc" do
+    it "ensures the definition was called" do
+      field = GraphQL::Field.define do
+        resolve ->(o, a, c) { :whatever }
+      end
+      assert_instance_of Proc, field.resolve_proc
+    end
+  end
 end

data/spec/graphql/query/variables_spec.rb

@@ -73,26 +73,168 @@ describe GraphQL::Query::Variables do
 
     describe "coercing null" do
       let(:provided_variables) {
-        {"int" => nil, "intWithDefault" => nil}
+        {
+          "intWithVariable" => nil,
+          "intWithDefault" => nil,
+          "complexValWithVariable" => {
+            "val" => 1,
+            "val_with_default" => 2,
+          },
+          "complexValWithDefaultAndVariable" => {
+            "val" => 8,
+          },
+        }
+      }
+      let(:args) { {} }
+      let(:schema) {
+        args_cache = args
+
+        complex_val = GraphQL::InputObjectType.define do
+          name "ComplexVal"
+          argument :val, types.Int
+          argument :val_with_default, types.Int, default_value: 13
+        end
+
+        query_type = GraphQL::ObjectType.define do
+          name "Query"
+          field :variables_test, types.Int do
+            argument :val, types.Int
+            argument :val_with_default, types.Int, default_value: 13
+            argument :complex_val, complex_val
+            resolve ->(o, a, c) {
+              args_cache[c.ast_node.alias] = a
+              1
+            }
+          end
+        end
+
+        GraphQL::Schema.define do
+          query(query_type)
+        end
+      }
+
+      let(:query_string) {<<-GRAPHQL
+        query testVariables(
+          $intWithVariable: Int,
+          $intWithDefault: Int = 10,
+          $intDefaultNull: Int = null,
+          $intWithoutVariable: Int,
+          $complexValWithVariable: ComplexVal,
+          $complexValWithoutVariable: ComplexVal,
+          $complexValWithOneDefault: ComplexVal = { val: 10 },
+          $complexValWithTwoDefaults: ComplexVal = { val: 11, val_with_default: 11 },
+          $complexValWithNullDefaults: ComplexVal = { val: null, val_with_default: null },
+          $complexValWithDefaultAndVariable: ComplexVal = { val: 99 },
+        ) {
+          aa: variables_test(val: $intWithVariable)
+          ab: variables_test(val: $intWithoutVariable)
+          ac: variables_test(val: $intWithDefault)
+          ad: variables_test(val: $intDefaultNull)
+
+          ba: variables_test(val_with_default: $intWithVariable)
+          bb: variables_test(val_with_default: $intWithoutVariable)
+          bc: variables_test(val_with_default: $intWithDefault)
+          bd: variables_test(val_with_default: $intDefaultNull)
+
+          ca: variables_test(complex_val: { val: $intWithVariable })
+          cb: variables_test(complex_val: { val: $intWithoutVariable })
+          cc: variables_test(complex_val: { val: $intWithDefault })
+          cd: variables_test(complex_val: { val: $intDefaultNull })
+
+          da: variables_test(complex_val: { val_with_default: $intWithVariable })
+          db: variables_test(complex_val: { val_with_default: $intWithoutVariable })
+          dc: variables_test(complex_val: { val_with_default: $intWithDefault })
+          dd: variables_test(complex_val: { val_with_default: $intDefaultNull })
+
+          ea: variables_test(complex_val: $complexValWithVariable)
+          eb: variables_test(complex_val: $complexValWithoutVariable)
+          ec: variables_test(complex_val: $complexValWithOneDefault)
+          ed: variables_test(complex_val: $complexValWithTwoDefaults)
+          ee: variables_test(complex_val: $complexValWithNullDefaults)
+          ef: variables_test(complex_val: $complexValWithDefaultAndVariable)
+        }
+      GRAPHQL
       }
 
+      let(:run_query) { schema.execute(query_string, variables: provided_variables) }
+
+      let(:variables) { GraphQL::Query::Variables.new(
+        schema,
+        GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+        ast_variables,
+        provided_variables)
+      }
+
+      def assert_has_key_with_value(hash, key, has_key, value)
+        assert_equal(has_key, hash.key?(key))
+        assert_equal(value, hash[key])
+      end
+
       it "preserves explicit null" do
-        assert_equal nil, variables["int"]
-        assert_equal true, variables.key?("int")
+        assert_has_key_with_value(variables, "intWithVariable", true, nil)
+        run_query
+        # Provided `nil` should be passed along to args
+        # and override any defaults (variable defaults and arg defaults)
+        assert_has_key_with_value(args["aa"], "val", true, nil)
+        assert_has_key_with_value(args["ba"], "val_with_default", true, nil)
+        assert_has_key_with_value(args["ca"]["complex_val"], "val", true, nil)
+        assert_has_key_with_value(args["da"]["complex_val"], "val_with_default", true, nil)
       end
 
       it "doesn't contain variables that weren't present" do
-        assert_equal nil, variables["animals"]
-        assert_equal false, variables.key?("animals")
+        assert_has_key_with_value(variables, "intWithoutVariable", false, nil)
+        run_query
+        assert_has_key_with_value(args["ab"], "val", false, nil)
+        # This one _is_ present, it gets the argument.default_value
+        assert_has_key_with_value(args["bb"], "val_with_default", true, 13)
+        assert_has_key_with_value(args["cb"]["complex_val"], "val", false, nil)
+        # This one _is_ present, it gets the argument.default_value
+        assert_has_key_with_value(args["db"]["complex_val"], "val_with_default", true, 13)
       end
 
       it "preserves explicit null when variable has a default value" do
-        assert_equal nil, variables["intWithDefault"]
+        assert_has_key_with_value(variables, "intWithDefault", true, nil)
+        run_query
+        assert_has_key_with_value(args["ac"], "val", true, nil)
+        assert_has_key_with_value(args["bc"], "val_with_default", true, nil)
+        assert_has_key_with_value(args["cc"]["complex_val"], "val", true, nil)
+        assert_has_key_with_value(args["dc"]["complex_val"], "val_with_default", true, nil)
       end
 
       it "uses null default value" do
-        assert_equal nil, variables["intDefaultNull"]
-        assert_equal true, variables.key?("intDefaultNull")
+        assert_has_key_with_value(variables, "intDefaultNull", true, nil)
+        run_query
+        assert_has_key_with_value(args["ad"], "val", true, nil)
+        assert_has_key_with_value(args["bd"], "val_with_default", true, nil)
+        assert_has_key_with_value(args["cd"]["complex_val"], "val", true, nil)
+        assert_has_key_with_value(args["dd"]["complex_val"], "val_with_default", true, nil)
+      end
+
+      it "applies argument default values" do
+        run_query
+        # It wasn't present in the query string, but it gets argument.default_value:
+        assert_has_key_with_value(args["aa"], "val_with_default", true, 13)
+      end
+
+      it "applies coercion to input objects passed as variables" do
+        run_query
+        assert_has_key_with_value(args["ea"]["complex_val"], "val", true, 1)
+        assert_has_key_with_value(args["ea"]["complex_val"], "val_with_default", true, 2)
+
+        # Since the variable wasn't provided, it's not present at all:
+        assert_has_key_with_value(args["eb"], "complex_val", false, nil)
+
+        assert_has_key_with_value(args["ec"]["complex_val"], "val", true, 10)
+        assert_has_key_with_value(args["ec"]["complex_val"], "val_with_default", true, 13)
+
+        assert_has_key_with_value(args["ed"]["complex_val"], "val", true, 11)
+        assert_has_key_with_value(args["ed"]["complex_val"], "val_with_default", true, 11)
+
+        assert_has_key_with_value(args["ee"]["complex_val"], "val", true, nil)
+        assert_has_key_with_value(args["ee"]["complex_val"], "val_with_default", true, nil)
+
+        assert_has_key_with_value(args["ef"]["complex_val"], "val", true, 8)
+        assert_has_key_with_value(args["ef"]["complex_val"], "val_with_default", true, 13)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-16 00:00:00.000000000 Z
+date: 2017-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter