graphql 1.5.4 → 1.5.5

data/lib/graphql/language/parser.y

@@ -265,7 +265,7 @@ rule
    | directive_definition
 
   schema_definition:
-      SCHEMA LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, val[2]) }
+      SCHEMA LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, position_source: val[0], **val[2]) }
 
   operation_type_definition_list:
       operation_type_definition
@@ -282,11 +282,11 @@ rule
     | enum_type_definition
     | input_object_type_definition
 
-  scalar_type_definition: SCALAR name directives_list_opt { return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2], description: get_description(val[0])) }
+  scalar_type_definition: SCALAR name directives_list_opt { return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2], description: get_description(val[0]), position_source: val[0]) }
 
   object_type_definition:
       TYPE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY {
-        return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], directives: val[3], fields: val[5], description: get_description(val[0]))
+        return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], directives: val[3], fields: val[5], description: get_description(val[0]), position_source: val[0])
       }
 
   implements_opt:
@@ -317,7 +317,7 @@ rule
 
   interface_type_definition:
       INTERFACE name directives_list_opt LCURLY field_definition_list RCURLY {
-        return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]))
+        return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   union_members:
@@ -326,22 +326,22 @@ rule
 
   union_type_definition:
       UNION name directives_list_opt EQUALS union_members {
-        return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]))
+        return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   enum_type_definition:
       ENUM name directives_list_opt LCURLY enum_value_definitions RCURLY {
-         return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]))
+         return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   input_object_type_definition:
       INPUT name directives_list_opt LCURLY input_value_definition_list RCURLY {
-        return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]))
+        return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   directive_definition:
       DIRECTIVE DIR_SIGN name arguments_definitions_opt ON directive_locations {
-        return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]))
+        return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]), position_source: val[0])
       }
 
   directive_locations:

data/lib/graphql/query.rb

@@ -65,12 +65,11 @@ module GraphQL
       end
 
       @document && @document.definitions.each do |part|
-        if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+        case part
+        when GraphQL::Language::Nodes::FragmentDefinition
           @fragments[part.name] = part
-        elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+        when GraphQL::Language::Nodes::OperationDefinition
           @operations[part.name] = part
-        else
-          raise GraphQL::ExecutionError, "GraphQL query cannot contain a schema definition"
         end
       end
 

data/lib/graphql/query/literal_input.rb

@@ -7,6 +7,8 @@ module GraphQL
         case ast_node
         when nil
           nil
+        when Language::Nodes::NullValue
+          nil
         when Language::Nodes::VariableIdentifier
           variables[ast_node.name]
         else

data/lib/graphql/relay/mutation.rb

@@ -169,9 +169,8 @@ module GraphQL
             input_field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
             relay_mutation.arguments.each do |input_field_name, field_obj|
               kwargs = {}
-              if field_obj.default_value?
-                kwargs[:default_value] = field_obj.default_value
-              end
+              kwargs[:default_value] = field_obj.default_value if field_obj.default_value?
+              kwargs[:as] = field_obj.as
               input_field(input_field_name, field_obj.type, field_obj.description, **kwargs)
             end
             mutation(relay_mutation)

data/lib/graphql/schema.rb

@@ -126,8 +126,7 @@ module GraphQL
 
       @possible_types = GraphQL::Schema::PossibleTypes.new(self)
 
-      @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
-      other.lazy_methods.each { |lazy_class, lazy_method| @lazy_methods.set(lazy_class, lazy_method) }
+      @lazy_methods = other.lazy_methods.dup
 
       @instrumenters = Hash.new { |h, k| h[k] = [] }
       other.instrumenters.each do |key, insts|
@@ -235,7 +234,6 @@ module GraphQL
       @possible_types.possible_types(type_defn)
     end
 
-
     # @see [GraphQL::Schema::Warden] Resticted access to root types
     # @return [GraphQL::ObjectType, nil]
     def root_type_for_operation(operation)

data/lib/graphql/schema/loader.rb

@@ -109,10 +109,32 @@ module GraphQL
             kwargs = {}
             if type["defaultValue"]
               kwargs[:default_value] = begin
-                JSON.parse(type["defaultValue"], quirks_mode: true)
-              rescue JSON::ParserError
-                # Enum values are not valid JSON, they're bare identifiers
-                type["default_value"]
+                default_value_str = type["defaultValue"]
+
+                dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+                # Returns a `GraphQL::Language::Nodes::Document`:
+                dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+                # Reach into the AST for the default value:
+                input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+                case input_value_ast
+                when String, Integer, Float, TrueClass, FalseClass, Array
+                  input_value_ast
+                when GraphQL::Language::Nodes::Enum
+                  input_value_ast.name
+                when GraphQL::Language::Nodes::NullValue
+                  nil
+                when GraphQL::Language::Nodes::InputObject
+                  input_value_ast.to_h
+                else
+                  raise(
+                    "Encountered unexpected type when loading default value. "\
+                    "input_value_ast.class is #{input_value_ast.class} "\
+                    "default_value is #{default_value_str}"
+                  )
+                end
               end
             end
 

data/lib/graphql/static_validation/all_rules.rb

@@ -7,6 +7,7 @@ module GraphQL
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [
+      GraphQL::StaticValidation::NoDefinitionsArePresent,
       GraphQL::StaticValidation::DirectivesAreDefined,
       GraphQL::StaticValidation::DirectivesAreInValidLocations,
       GraphQL::StaticValidation::UniqueDirectivesPerLocation,

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -32,7 +32,6 @@ module GraphQL
         @dependency_map ||= resolve_dependencies(&block)
       end
 
-
       def mount(context)
         visitor = context.visitor
         # When we encounter a spread,

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class NoDefinitionsArePresent
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      def validate(context)
+        schema_definition_nodes = []
+        register_node = ->(node, _p) {
+          schema_definition_nodes << node
+          GraphQL::Language::Visitor::SKIP
+        }
+
+        visitor = context.visitor
+        visitor[GraphQL::Language::Nodes::DirectiveDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::SchemaDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::ScalarTypeDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::ObjectTypeDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::InputObjectTypeDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::InterfaceTypeDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::UnionTypeDefinition] << register_node
+        visitor[GraphQL::Language::Nodes::EnumTypeDefinition] << register_node
+
+        visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _p) {
+          if schema_definition_nodes.any?
+            context.errors << message(%|Query cannot contain schema definitions|, schema_definition_nodes, context: context)
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -14,19 +14,25 @@ module GraphQL
 
         context.visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
           return if !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          if parent.is_a?(GraphQL::Language::Nodes::Field)
+          arguments = nil
+
+          case parent
+          when GraphQL::Language::Nodes::Field
             arguments = context.field_definition.arguments
-          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
+          when GraphQL::Language::Nodes::Directive
             arguments = context.directive_definition.arguments
-          elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-            arguments = context.argument_definition.type.unwrap.input_fields
+          when GraphQL::Language::Nodes::InputObject
+            arg_type = context.argument_definition.type.unwrap
+            if arg_type.is_a?(GraphQL::InputObjectType)
+              arguments = arg_type.input_fields
+            end
           else
             raise("Unexpected argument parent: #{parent}")
           end
           var_defn_ast = declared_variables[node.value.name]
           # Might be undefined :(
           # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-          var_defn_ast && validate_usage(arguments, node, var_defn_ast, context)
+          var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast, context)
         }
       end
 

data/lib/graphql/static_validation/validation_context.rb

@@ -36,7 +36,6 @@ module GraphQL
         }
       end
 
-
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler
       end

data/lib/graphql/version.rb

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

data/spec/graphql/define/instance_definable_spec.rb

@@ -78,6 +78,27 @@ describe GraphQL::Define::InstanceDefinable do
       okra.define { name "Okra" }
       assert_equal "Okra", okra.name
     end
+
+    describe "errors in define blocks" do
+      it "preserves the definition block to try again" do
+        magic_number = 12
+
+        radish = Garden::Vegetable.define {
+          name "Pre-error"
+          magic_number += 1
+          if magic_number == 13
+            raise "👻"
+          end
+          name "Radish"
+        }
+
+        # The first call triggers an error:
+        assert_raises(RuntimeError) { radish.name }
+        # Calling definintion-dependent method should re-run the block,
+        # not leave old values around:
+        assert_equal "Radish", radish.name
+      end
+    end
   end
 
   describe "#redefine" do

data/spec/graphql/execution/execute_spec.rb

@@ -76,4 +76,65 @@ describe GraphQL::Execution::Execute do
       end
     end
   end
+
+  describe "when a list member raises an error" do
+    let(:schema) {
+      thing_type = GraphQL::ObjectType.define do
+        name "Thing"
+        field :name, !types.String do
+          resolve ->(o, a, c) {
+            -> {
+              raise GraphQL::ExecutionError.new("👻")
+            }
+          }
+        end
+      end
+
+      query_type = GraphQL::ObjectType.define do
+        name "Query"
+        field :things, !types[!thing_type] do
+          resolve ->(o, a, c) {
+            [OpenStruct.new(name: "A")]
+          }
+        end
+
+        field :nullableThings, !types[thing_type] do
+          resolve ->(o, a, c) {
+            [OpenStruct.new(name: "A")]
+          }
+        end
+      end
+
+      GraphQL::Schema.define do
+        query query_type
+        lazy_resolve(Proc, :call)
+      end
+    }
+
+    it "handles the error & propagates the null" do
+      res = schema.execute <<-GRAPHQL
+      {
+        things {
+          name
+        }
+      }
+      GRAPHQL
+
+      assert_equal nil, res["data"]
+      assert_equal "👻", res["errors"].first["message"]
+    end
+
+    it "allows nulls" do
+      res = schema.execute <<-GRAPHQL
+      {
+        nullableThings {
+          name
+        }
+      }
+      GRAPHQL
+
+      assert_equal [nil], res["data"]["nullableThings"]
+      assert_equal "👻", res["errors"].first["message"]
+    end
+  end
 end

data/spec/graphql/execution/lazy/lazy_method_map_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Execution::Lazy::LazyMethodMap do
+  def self.test_lazy_method_map
+    it "handles multithreaded access" do
+      a = Class.new
+      b = Class.new(a)
+      c = Class.new(b)
+      lazy_method_map.set(a, :a)
+      threads = 1000.times.map do |i|
+        Thread.new {
+          d = Class.new(c)
+          assert_equal :a, lazy_method_map.get(d.new)
+        }
+      end
+      threads.map(&:join)
+    end
+
+    it "dups" do
+      a = Class.new
+      b = Class.new(a)
+      c = Class.new(b)
+      lazy_method_map.set(a, :a)
+      lazy_method_map.get(b.new)
+      lazy_method_map.get(c.new)
+
+      dup_map = lazy_method_map.dup
+      assert_equal 3, dup_map.instance_variable_get(:@storage).size
+      assert_equal :a, dup_map.get(a.new)
+      assert_equal :a, dup_map.get(b.new)
+      assert_equal :a, dup_map.get(c.new)
+    end
+  end
+
+  describe "with a plain hash" do
+    let(:lazy_method_map) { GraphQL::Execution::Lazy::LazyMethodMap.new(use_concurrent: false) }
+    test_lazy_method_map
+
+    it "has a Ruby Hash inside" do
+      storage = lazy_method_map
+        .instance_variable_get(:@storage)
+        .instance_variable_get(:@storage)
+      assert_instance_of Hash, storage
+    end
+  end
+
+  describe "with a Concurrent::Map" do
+    let(:lazy_method_map) { GraphQL::Execution::Lazy::LazyMethodMap.new(use_concurrent: true) }
+    test_lazy_method_map
+
+    it "has a Concurrent::Map inside" do
+      storage = lazy_method_map.instance_variable_get(:@storage)
+      assert_instance_of Concurrent::Map, storage
+    end
+  end
+end

data/spec/graphql/input_object_type_spec.rb

@@ -325,8 +325,8 @@ describe GraphQL::InputObjectType do
     it "shallow-copies internal state" do
       input_object_2 = input_object.dup
       input_object_2.arguments["nonsense"] = GraphQL::Argument.define(name: "int", type: GraphQL::INT_TYPE)
-      assert_equal 4, input_object.arguments.size
-      assert_equal 5, input_object_2.arguments.size
+      assert_equal 5, input_object.arguments.size
+      assert_equal 6, input_object_2.arguments.size
     end
   end
 end

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -34,7 +34,9 @@ describe GraphQL::Introspection::InputValueType do
             {"name"=>"fatContent", "type"=>{"kind"=>"SCALAR",  "name" => "Float"}, "defaultValue"=>"0.3",
              "description" => "How much fat it has"},
             {"name"=>"organic", "type"=>{"kind"=>"SCALAR",  "name" => "Boolean"}, "defaultValue"=>"false",
-             "description" => nil}
+             "description" => nil},
+            {"name"=>"order_by", "type"=>{"kind"=>"INPUT_OBJECT", "name"=>"ResourceOrderType"}, "defaultValue"=>"{direction:\"ASC\"}",
+             "description" => nil},
           ]
         }
       }}

data/spec/graphql/introspection/type_type_spec.rb

@@ -122,6 +122,7 @@ describe GraphQL::Introspection::TypeType do
                 {"name"=>"originDairy", "type"=>{"kind"=>"SCALAR","name"=>"String"}, "defaultValue"=>"\"Sugar Hollow Dairy\""},
                 {"name"=>"fatContent", "type"=>{"kind"=>"SCALAR","name" => "Float"}, "defaultValue"=>"0.3"},
                 {"name"=>"organic", "type"=>{"kind"=>"SCALAR","name" => "Boolean"}, "defaultValue"=>"false"},
+                {"name"=>"order_by", "type"=>{"kind"=>"INPUT_OBJECT", "name"=>"ResourceOrderType"}, "defaultValue"=>"{direction:\"ASC\"}"},
               ]
             }
           }}

data/spec/graphql/query_spec.rb

@@ -143,16 +143,6 @@ describe GraphQL::Query do
     end
   end
 
-  it "fails to execute a query containing a type definition" do
-    query_string = '
-      { root }
-
-      type Query { foo: String }
-    '
-    exc = assert_raises(GraphQL::ExecutionError) { GraphQL::Query.new(schema, query_string) }
-    assert_equal "GraphQL query cannot contain a schema definition", exc.message
-  end
-
   it "uses root_value as the object for the root type" do
     result = GraphQL::Query.new(schema, '{ root }', root_value: "I am root").result
     assert_equal 'I am root', result.fetch('data').fetch('root')
@@ -470,4 +460,73 @@ describe GraphQL::Query do
       }
     end
   end
+
+  describe 'NullValue type arguments' do
+    let(:schema_definition) {
+      <<-GRAPHQL
+        type Query {
+          foo(id: [ID]): Int
+        }
+      GRAPHQL
+    }
+    let(:expected_args) { [] }
+    let(:default_resolver) do
+      {
+        'Query' => { 'foo' => ->(_obj, args, _ctx) { expected_args.push(args); 1 } },
+      }
+    end
+    let(:schema) { GraphQL::Schema.from_definition(schema_definition, default_resolve: default_resolver) }
+
+    it 'sets argument to nil when null is passed' do
+      query = <<-GRAPHQL
+        {
+          foo(id: null)
+        }
+      GRAPHQL
+
+      schema.execute(query)
+
+      assert(expected_args.first.key?('id'))
+      assert_nil(expected_args.first['id'])
+    end
+
+    it 'sets argument to nil when nil is passed via variable' do
+      query = <<-GRAPHQL
+        query baz($id: [ID]) {
+          foo(id: $id)
+        }
+      GRAPHQL
+
+      schema.execute(query, variables: { 'id' => nil })
+
+      assert(expected_args.first.key?('id'))
+      assert([nil], expected_args.first['id'])
+    end
+
+    it 'sets argument to [nil] when [null] is passed' do
+      query = <<-GRAPHQL
+        {
+          foo(id: [null])
+        }
+      GRAPHQL
+
+      schema.execute(query)
+
+      assert(expected_args.first.key?('id'))
+      assert_equal([nil], expected_args.first['id'])
+    end
+
+    it 'sets argument to [nil] when [nil] is passed via variable' do
+      query = <<-GRAPHQL
+        query baz($id: [ID]) {
+          foo(id: $id)
+        }
+      GRAPHQL
+
+      schema.execute(query, variables: { 'id' => [nil] })
+
+      assert(expected_args.first.key?('id'))
+      assert_equal([nil], expected_args.first['id'])
+    end
+  end
 end