graphql 1.5.5 → 1.5.6

data/lib/graphql/schema/build_from_definition.rb

@@ -105,6 +105,8 @@ module GraphQL
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
           Schema.define do
+            raise_definition_error true
+
             query query_root_type
             mutation mutation_root_type
             subscription subscription_root_type
@@ -119,7 +121,7 @@ module GraphQL
           raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
         }
 
-        NullScalarCoerce = ->(val) { val }
+        NullScalarCoerce = ->(val, _ctx) { val }
 
         def build_enum_type(enum_type_definition, type_resolver)
           GraphQL::EnumType.define(

data/lib/graphql/schema/catchall_middleware.rb

@@ -27,7 +27,7 @@ module GraphQL
       # whose message is {MESSAGE}
       def self.call(parent_type, parent_object, field_definition, field_args, query_context)
         yield
-      rescue StandardError => err
+      rescue StandardError
         GraphQL::ExecutionError.new(MESSAGE)
       end
     end

data/lib/graphql/schema/default_type_error.rb

@@ -6,7 +6,7 @@ module GraphQL
         case type_error
         when GraphQL::InvalidNullError
           ctx.errors << type_error
-        when GraphQL::UnresolvedTypeError
+        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError
           raise type_error
         end
       end

data/lib/graphql/schema/loader.rb

@@ -30,14 +30,14 @@ module GraphQL
           kargs[root] = types.fetch(type.fetch("name")) if type
         end
 
-        Schema.define(**kargs)
+        Schema.define(**kargs, raise_definition_error: true)
       end
 
       NullResolveType = ->(obj, ctx) {
         raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
       }
 
-      NullScalarCoerce = ->(val) { val }
+      NullScalarCoerce = ->(val, _ctx) { val }
 
       class << self
         private

data/lib/graphql/schema/printer.rb

@@ -218,7 +218,7 @@ module GraphQL
               value.to_s.inspect
             when EnumType
               return 'null' if value.nil?
-              type.coerce_result(value)
+              type.coerce_isolated_result(value)
             when InputObjectType
               return 'null' if value.nil?
               fields = value.to_h.map{ |field_name, field_value|

data/lib/graphql/schema/validation.rb

@@ -39,7 +39,6 @@ module GraphQL
         def self.assert_property_mapping(property_name, from_class, to_class)
           ->(obj) {
             property_value = obj.public_send(property_name)
-            error_message = nil
             if !property_value.is_a?(Hash)
               "#{property_name} must be a hash of {#{from_class.name} => #{to_class.name}}, not a #{property_value.class.name} (#{property_value.inspect})"
             else
@@ -105,7 +104,7 @@ module GraphQL
 
           if !type.default_value.nil?
             coerced_value = begin
-              type.type.coerce_result(type.default_value)
+              type.type.coerce_isolated_result(type.default_value)
             rescue => ex
               ex
             end

data/lib/graphql/static_validation/arguments_validator.rb

@@ -33,7 +33,7 @@ module GraphQL
       private
 
       def parent_name(parent, type_defn)
-        field_name = if parent.is_a?(GraphQL::Language::Nodes::Field)
+        if parent.is_a?(GraphQL::Language::Nodes::Field)
           parent.alias || parent.name
         elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
           type_defn.name

data/lib/graphql/static_validation/literal_validator.rb

@@ -3,8 +3,9 @@ module GraphQL
   module StaticValidation
     # Test whether `ast_value` is a valid input for `type`
     class LiteralValidator
-      def initialize(warden:)
-        @warden = warden
+      def initialize(context:)
+        @context = context
+        @warden = context.warden
       end
 
       def validate(ast_value, type)
@@ -16,9 +17,9 @@ module GraphQL
           item_type = type.of_type
           ensure_array(ast_value).all? { |val| validate(val, item_type) }
         elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
-          type.valid_input?(ast_value, @warden)
+          type.valid_input?(ast_value, @context)
         elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-          type.valid_input?(ast_value.name, @warden)
+          type.valid_input?(ast_value.name, @context)
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           required_input_fields_are_present(type, ast_value) &&
             present_input_field_values_are_valid(type, ast_value)

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

@@ -12,7 +12,7 @@ module GraphQL
         }
 
         context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _parent) {
-          op_count = op_names.values.inject(0) { |m, v| m += v.size }
+          op_count = op_names.values.inject(0) { |m, v| m + v.size }
 
           op_names.each do |name, nodes|
             if name.nil? && op_count > 1

data/lib/graphql/static_validation/validation_context.rb

@@ -22,7 +22,7 @@ module GraphQL
 
       def initialize(query)
         @query = query
-        @literal_validator = LiteralValidator.new(warden: warden)
+        @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
         @visitor = GraphQL::Language::Visitor.new(document)
         @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)

data/lib/graphql/string_encoding_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  class StringEncodingError < GraphQL::RuntimeTypeError
+    attr_reader :string
+    def initialize(str)
+      @string = str
+      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires UTF-8 encoding.")
+    end
+  end
+end

data/lib/graphql/string_type.rb

@@ -3,11 +3,16 @@ GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
   name "String"
   description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
 
-  coerce_result ->(value) {
+  coerce_result ->(value, ctx) {
     str = value.to_s
-    str.encoding == Encoding::US_ASCII || str.encoding == Encoding::UTF_8 ? str : nil
+    if str.encoding == Encoding::US_ASCII || str.encoding == Encoding::UTF_8
+      str
+    else
+      err = GraphQL::StringEncodingError.new(str)
+      ctx.schema.type_error(err, ctx)
+    end
   }
 
-  coerce_input ->(value) { value.is_a?(String) ? value : nil }
+  coerce_input ->(value, _ctx) { value.is_a?(String) ? value : nil }
   default_scalar true
 end

data/lib/graphql/version.rb

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

data/spec/graphql/argument_spec.rb

@@ -57,4 +57,17 @@ describe GraphQL::Argument do
       assert_equal arg_3.expose_as, "ff"
     end
   end
+
+  describe "prepare" do
+    it "accepts a prepare proc and calls it to generate the prepared value" do
+      prepare_proc = Proc.new { |arg| arg + 1 }
+      argument = GraphQL::Argument.define(name: :plusOne, type: GraphQL::INT_TYPE, prepare: prepare_proc)
+      assert_equal argument.prepare(1), 2
+    end
+
+    it "returns the value itself if no prepare proc is provided" do
+      argument = GraphQL::Argument.define(name: :someNumber, type: GraphQL::INT_TYPE)
+      assert_equal argument.prepare(1), 1
+    end
+  end
 end

data/spec/graphql/base_type_spec.rb

@@ -43,7 +43,7 @@ describe GraphQL::BaseType do
       obj_2 = obj_type.dup
       obj_2.name = "Cheese2"
       refute_equal obj_edge, obj_2.edge_type
-      refute_equal obj_edge, obj_2.connection_type
+      refute_equal obj_conn, obj_2.connection_type
     end
   end
 

data/spec/graphql/boolean_type_spec.rb

@@ -4,7 +4,7 @@ require "spec_helper"
 describe GraphQL::BOOLEAN_TYPE do
   describe "coerce_input" do
     def coerce_input(input)
-      GraphQL::BOOLEAN_TYPE.coerce_input(input)
+      GraphQL::BOOLEAN_TYPE.coerce_isolated_input(input)
     end
 
     it "accepts true and false" do

data/spec/graphql/enum_type_spec.rb

@@ -5,34 +5,34 @@ describe GraphQL::EnumType do
   let(:enum) { Dummy::DairyAnimalEnum }
 
   it "coerces names to underlying values" do
-    assert_equal("YAK", enum.coerce_input("YAK"))
-    assert_equal(1, enum.coerce_input("COW"))
+    assert_equal("YAK", enum.coerce_isolated_input("YAK"))
+    assert_equal(1, enum.coerce_isolated_input("COW"))
   end
 
   it "coerces invalid names to nil" do
-    assert_equal(nil, enum.coerce_input("YAKKITY"))
+    assert_equal(nil, enum.coerce_isolated_input("YAKKITY"))
   end
 
   it "coerces result values to value's value" do
-    assert_equal("YAK", enum.coerce_result("YAK"))
-    assert_equal("COW", enum.coerce_result(1))
-    assert_equal("REINDEER", enum.coerce_result('reindeer'))
-    assert_equal("DONKEY", enum.coerce_result(:donkey))
+    assert_equal("YAK", enum.coerce_isolated_result("YAK"))
+    assert_equal("COW", enum.coerce_isolated_result(1))
+    assert_equal("REINDEER", enum.coerce_isolated_result('reindeer'))
+    assert_equal("DONKEY", enum.coerce_isolated_result(:donkey))
   end
 
   it "raises when a result value can't be coerced" do
     assert_raises(GraphQL::EnumType::UnresolvedValueError) {
-      enum.coerce_result(:nonsense)
+      enum.coerce_isolated_result(:nonsense)
     }
   end
 
   describe "resolving with a warden" do
     it "gets values from the warden" do
       # OK
-      assert_equal("YAK", enum.coerce_result("YAK"))
+      assert_equal("YAK", enum.coerce_isolated_result("YAK"))
       # NOT OK
       assert_raises(GraphQL::EnumType::UnresolvedValueError) {
-        enum.coerce_result("YAK", NothingWarden)
+        enum.coerce_result("YAK", OpenStruct.new(warden: NothingWarden))
       }
     end
   end
@@ -84,7 +84,7 @@ describe GraphQL::EnumType do
   end
 
   describe "validate_input with bad input" do
-    let(:result) { enum.validate_input("bad enum", PermissiveWarden) }
+    let(:result) { enum.validate_isolated_input("bad enum") }
 
     it "returns an invalid result" do
       assert(!result.valid?)

data/spec/graphql/field_spec.rb

@@ -90,7 +90,7 @@ describe GraphQL::Field do
       dummy_query.fields["symbol_name"] = invalid_field
 
       err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-        GraphQL::Schema.define(query: dummy_query)
+        GraphQL::Schema.define(query: dummy_query, raise_definition_error: true)
       }
       assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message
     end

data/spec/graphql/float_type_spec.rb

@@ -4,13 +4,13 @@ require "spec_helper"
 describe GraphQL::FLOAT_TYPE do
   describe "coerce_input" do
     it "accepts ints and floats" do
-      assert_equal 1.0, GraphQL::FLOAT_TYPE.coerce_input(1)
-      assert_equal 6.1, GraphQL::FLOAT_TYPE.coerce_input(6.1)
+      assert_equal 1.0, GraphQL::FLOAT_TYPE.coerce_isolated_input(1)
+      assert_equal 6.1, GraphQL::FLOAT_TYPE.coerce_isolated_input(6.1)
     end
 
     it "rejects other types" do
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input("55")
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input(true)
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/function_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 describe GraphQL::Function do
   class TestFunc < GraphQL::Function
     argument :name, GraphQL::STRING_TYPE
+    argument :age, types.Int
     type do
       name "TestFuncPayload"
       field :name, types.String, hash_key: :name
@@ -20,7 +21,7 @@ describe GraphQL::Function do
   describe "function API" do
     it "exposes required info" do
       f = TestFunc.new
-      assert_equal ["name"], f.arguments.keys
+      assert_equal ["name", "age"], f.arguments.keys
       assert_equal "TestFuncPayload", f.type.name
       assert_equal "Returns the string you give it", f.description
       assert_equal "It's useless", f.deprecation_reason
@@ -69,7 +70,7 @@ describe GraphQL::Function do
 
     it "gets attributes from the function" do
       field = schema.query.fields["test"]
-      assert_equal ["name"], field.arguments.keys
+      assert_equal ["name", "age"], field.arguments.keys
       assert_equal "TestFuncPayload", field.type.name
       assert_equal "Returns the string you give it", field.description
       assert_equal "It's useless", field.deprecation_reason
@@ -115,14 +116,14 @@ describe GraphQL::Function do
     it "can override description" do
       field = schema.query.fields["blockOverride"]
       assert_equal "I have altered the description", field.description
-      assert_equal ["name", "anArg", "oneMoreArg"], field.arguments.keys
+      assert_equal ["name", "age", "anArg", "oneMoreArg"], field.arguments.keys
     end
 
     it "can add to arguments" do
       field = schema.query.fields["argOverride"]
       assert_equal "New Description", field.description
       assert_equal GraphQL::STRING_TYPE, field.type
-      assert_equal ["name"], field.arguments.keys
+      assert_equal ["name", "age"], field.arguments.keys
     end
   end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -26,18 +26,18 @@ describe GraphQL::InputObjectType do
   describe "input validation" do
     it "Accepts anything that yields key-value pairs to #all?" do
       values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})
-      assert input_object.valid_input?(values_obj, PermissiveWarden)
+      assert input_object.valid_isolated_input?(values_obj)
     end
 
     describe "validate_input with non-enumerable input" do
       it "returns a valid result for MinimumInputObject" do
-        result = input_object.validate_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}), PermissiveWarden)
+        result = input_object.validate_isolated_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
         assert(result.valid?)
       end
 
       it "returns an invalid result for MinimumInvalidInputObject" do
         invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
-        result = input_object.validate_input(invalid_input, PermissiveWarden)
+        result = input_object.validate_isolated_input(invalid_input)
         assert(!result.valid?)
       end
     end
@@ -57,13 +57,13 @@ describe GraphQL::InputObjectType do
 
       it "returns an invalid result when value is null for non-null argument" do
         invalid_input = MinimumInputObject.new({"a" => "Test", "b" => nil})
-        result = input_type.validate_input(invalid_input, PermissiveWarden)
+        result = input_type.validate_isolated_input(invalid_input)
         assert(!result.valid?)
       end
 
       it "returns valid result when value is null for nullable argument" do
         invalid_input = MinimumInputObject.new({"a" => nil, "b" => 1})
-        result = input_type.validate_input(invalid_input, PermissiveWarden)
+        result = input_type.validate_isolated_input(invalid_input)
         assert(result.valid?)
       end
     end
@@ -76,7 +76,7 @@ describe GraphQL::InputObjectType do
             "fatContent" => 0.4
           }
         end
-        let(:result) { input_object.validate_input(input, PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input(input) }
 
         it "returns a valid result" do
           assert(result.valid?)
@@ -91,7 +91,7 @@ describe GraphQL::InputObjectType do
               "fatContent" => 0.4,
             )
           end
-          let(:result) { input_object.validate_input(input, PermissiveWarden) }
+          let(:result) { input_object.validate_isolated_input(input) }
 
           it "returns a valid result" do
             assert(result.valid?)
@@ -100,7 +100,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with bad enum and float" do
-        let(:result) { input_object.validate_input({"source" => "KOALA", "fatContent" => "bad_num"}, PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input({"source" => "KOALA", "fatContent" => "bad_num"}) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -113,7 +113,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has correct problem explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
+          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
 
           source_problem = result.problems.detect { |p| p["path"] == ["source"] }
           actual = source_problem["explanation"]
@@ -123,7 +123,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with a string as input' do
-        let(:result) { input_object.validate_input("just a string", PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input("just a string") }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -140,7 +140,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with an array as input' do
-        let(:result) { input_object.validate_input(["string array"], PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input(["string array"]) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -157,7 +157,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe 'with a int as input' do
-        let(:result) { input_object.validate_input(10, PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input(10) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -174,7 +174,7 @@ describe GraphQL::InputObjectType do
       end
 
       describe "with extra argument" do
-        let(:result) { input_object.validate_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}, PermissiveWarden) }
+        let(:result) { input_object.validate_isolated_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}) }
 
         it "returns an invalid result" do
           assert(!result.valid?)
@@ -193,10 +193,10 @@ describe GraphQL::InputObjectType do
       describe "list with one invalid element" do
         let(:list_type) { GraphQL::ListType.new(of_type: Dummy::DairyProductInputType) }
         let(:result) do
-          list_type.validate_input([
+          list_type.validate_isolated_input([
             { "source" => "COW", "fatContent" => 0.4 },
             { "source" => "KOALA", "fatContent" => 0.4 }
-          ], PermissiveWarden)
+          ])
         end
 
         it "returns an invalid result" do
@@ -213,7 +213,7 @@ describe GraphQL::InputObjectType do
         end
 
         it "has problem with correct explanation" do
-          expected = Dummy::DairyAnimalEnum.validate_input("KOALA", PermissiveWarden).problems[0]["explanation"]
+          expected = Dummy::DairyAnimalEnum.validate_isolated_input("KOALA").problems[0]["explanation"]
           actual = result.problems[0]["explanation"]
           assert_equal(expected, actual)
         end
@@ -223,7 +223,7 @@ describe GraphQL::InputObjectType do
 
   describe "coerce_result" do
     it "omits unspecified arguments" do
-      result = input_object.coerce_result(fatContent: 0.3)
+      result = input_object.coerce_isolated_result({fatContent: 0.3})
       assert_equal ["fatContent"], result.keys
       assert_equal 0.3, result["fatContent"]
     end
@@ -239,13 +239,14 @@ describe GraphQL::InputObjectType do
         a: String
         b: Int!
         c: String = "Default"
+        d: Boolean = false
       }
     |) }
     let(:input_type) { schema.types['ExampleInputObject'] }
 
     it "null values are returned in coerced input" do
       input = MinimumInputObject.new({"a" => "Test", "b" => nil,"c" => "Test"})
-      result = input_type.coerce_input(input)
+      result = input_type.coerce_isolated_input(input)
 
       assert_equal 'Test', result['a']
 
@@ -257,7 +258,7 @@ describe GraphQL::InputObjectType do
 
     it "null values are preserved when argument has a default value" do
       input = MinimumInputObject.new({"a" => "Test", "b" => 1, "c" => nil})
-      result = input_type.coerce_input(input)
+      result = input_type.coerce_isolated_input(input)
 
       assert_equal 'Test', result['a']
       assert_equal 1, result['b']
@@ -268,12 +269,19 @@ describe GraphQL::InputObjectType do
 
     it "omitted arguments are not returned" do
       input = MinimumInputObject.new({"b" => 1, "c" => "Test"})
-      result = input_type.coerce_input(input)
+      result = input_type.coerce_isolated_input(input)
 
       assert !result.key?('a')
       assert_equal 1, result['b']
       assert_equal 'Test', result['c']
     end
+
+    it "false default values are returned" do
+      input = MinimumInputObject.new({"b" => 1})
+      result = input_type.coerce_isolated_input(input)
+
+      assert_equal false, result['d']
+    end
   end
 
   describe "when sent into a query" do