graphql 1.6.4 → 1.6.5

data/lib/graphql/schema/validation.rb

@@ -274,10 +274,10 @@ module GraphQL
           Rules::FIELDS_ARE_VALID,
         ],
         GraphQL::Schema => [
+          Rules::SCHEMA_INSTRUMENTERS_ARE_VALID,
           Rules::SCHEMA_CAN_RESOLVE_TYPES,
           Rules::SCHEMA_CAN_FETCH_IDS,
           Rules::SCHEMA_CAN_GENERATE_IDS,
-          Rules::SCHEMA_INSTRUMENTERS_ARE_VALID,
         ],
       }
     end

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

@@ -7,15 +7,15 @@ module GraphQL
       def validate(context)
         # holds { name => ast_node } pairs
         declared_variables = {}
-
         context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
           declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
         }
 
         context.visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
-          return if !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          arguments = nil
+          node_values = Array.wrap(node.value).select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
+          return if node_values.none?
 
+          arguments = nil
           case parent
           when GraphQL::Language::Nodes::Field
             arguments = context.field_definition.arguments
@@ -29,10 +29,13 @@ module GraphQL
           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 && arguments && validate_usage(arguments, node, var_defn_ast, context)
+
+          node_values.each do |node_value|
+            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 && arguments && validate_usage(arguments, node, var_defn_ast, context)
+          end
         }
       end
 
@@ -53,6 +56,8 @@ module GraphQL
         var_inner_type = var_type.unwrap
         arg_inner_type = arg_defn_type.unwrap
 
+        var_type = wrap_var_type_with_depth_of_arg(var_type, arg_node)
+
         if var_inner_type != arg_inner_type
           context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node, context)
         elsif list_dimension(var_type) != list_dimension(arg_defn_type)
@@ -66,6 +71,35 @@ module GraphQL
         message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node, context: context)
       end
 
+      def wrap_var_type_with_depth_of_arg(var_type, arg_node)
+        arg_node_value = arg_node.value
+        return var_type unless arg_node_value.is_a?(Array)
+        new_var_type = var_type
+
+        depth_of_array(arg_node_value).times do
+          new_var_type = GraphQL::ListType.new(of_type: new_var_type)
+        end
+
+        new_var_type
+      end
+
+      # @return [Integer] Returns the max depth of `array`, or `0` if it isn't an array at all
+      def depth_of_array(array)
+        case array
+        when Array
+          max_child_depth = 0
+          array.each do |item|
+            item_depth = depth_of_array(item)
+            if item_depth > max_child_depth
+              max_child_depth = item_depth
+            end
+          end
+          1 + max_child_depth
+        else
+          0
+        end
+      end
+
       def list_dimension(type)
         if type.kind.list?
           1 + list_dimension(type.of_type)

data/lib/graphql/union_type.rb

@@ -24,13 +24,16 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types
-    ensure_defined :possible_types
+    accepts_definitions :possible_types, :resolve_type
+    ensure_defined :possible_types, :resolve_type, :resolve_type_proc
+
+    attr_accessor :resolve_type_proc
 
     def initialize
       super
       @dirty_possible_types = []
       @clean_possible_types = nil
+      @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
@@ -64,6 +67,14 @@ module GraphQL
       end
     end
 
+    def resolve_type(value, ctx)
+      ctx.query.resolve_type(self, value)
+    end
+
+    def resolve_type=(new_resolve_type_proc)
+      @resolve_type_proc = new_resolve_type_proc
+    end
+
     protected
 
     attr_reader :dirty_possible_types

data/lib/graphql/version.rb

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

data/readme.md

@@ -49,6 +49,4 @@ I also sell [GraphQL::Pro](http://graphql.pro) which provides several features o
 
 - __Say hi & ask questions__ in the [#ruby channel on Slack](https://graphql-slack.herokuapp.com/) or [on Twitter](https://twitter.com/rmosolgo)!
 - __Report bugs__ by posting a description, full stack trace, and all relevant code in a  [GitHub issue](https://github.com/rmosolgo/graphql-ruby/issues).
-- __Features & patches__ are welcome! Consider discussing it in an [issue](https://github.com/rmosolgo/graphql-ruby/issues) or in the [#ruby channel on Slack](https://graphql-slack.herokuapp.com/) to make sure we're on the same page.
-- __Run the tests__ with `rake test` or start up guard with `bundle exec guard`.
-- __Build the site__ with `rake site:serve`, then visit `http://localhost:4000/graphql-ruby/`.
+- __Start hacking__ with the [Development guide](http://graphql-ruby.org/development).

data/spec/generators/graphql/install_generator_spec.rb

@@ -37,6 +37,7 @@ class GraphQLGeneratorsInstallGeneratorTest < Rails::Generators::TestCase
 
     expected_schema = <<-RUBY
 DummySchema = GraphQL::Schema.define do
+  mutation(Types::MutationType)
   query(Types::QueryType)
 end
 RUBY
@@ -160,8 +161,9 @@ RUBY
 
   EXPECTED_RELAY_BATCH_SCHEMA = <<-RUBY
 DummySchema = GraphQL::Schema.define do
-  query(Types::QueryType)
 
+  mutation(Types::MutationType)
+  query(Types::QueryType)
   # Relay Object Identification:
 
   # Return a string UUID for `object`

data/spec/generators/graphql/mutation_generator_spec.rb

@@ -5,6 +5,20 @@ require "generators/graphql/mutation_generator"
 class GraphQLGeneratorsMutationGeneratorTest < BaseGeneratorTest
   tests Graphql::Generators::MutationGenerator
 
+  destination File.expand_path("../../../tmp/dummy", File.dirname(__FILE__))
+
+  setup do
+    prepare_destination
+    FileUtils.cd(File.expand_path("../../../tmp", File.dirname(__FILE__))) do
+      `rm -rf dummy`
+      `rails new dummy --skip-active-record --skip-test-unit --skip-spring --skip-bundle`
+    end
+
+    FileUtils.cd(destination_root) do
+      `rails g graphql:install`
+    end
+  end
+
   test "it generates an empty resolver by name" do
     run_generator(["UpdateName"])
 

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -50,7 +50,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
     end
   end
 
-  describe "when complexity is overriden at query-level" do
+  describe "when max_complexity is decreased at query-level" do
     before do
       Dummy::Schema.max_complexity = 100
     end
@@ -61,6 +61,17 @@ describe GraphQL::Analysis::MaxQueryComplexity do
     end
   end
 
+  describe "when max_complexity is increased at query-level" do
+    before do
+      Dummy::Schema.max_complexity = 1
+    end
+    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 10) }
+
+    it "doesn't error" do
+      assert_equal nil, result["errors"]
+    end
+  end
+
   describe "across a multiplex" do
     before do
       Dummy::Schema.max_complexity = 9

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -260,7 +260,7 @@ describe GraphQL::Analysis::QueryComplexity do
       GraphQL::Schema.define(
         query: query_type,
         orphan_types: [double_complexity_type],
-        resolve_type: :pass
+        resolve_type: ->(a,b,c) { :pass }
       )
     }
     let(:query_string) {%|

data/spec/graphql/argument_spec.rb

@@ -19,6 +19,18 @@ describe GraphQL::Argument do
     assert_includes err.message, expected_error
   end
 
+  it "accepts custom keywords" do
+    type = GraphQL::ObjectType.define do
+      name "Something"
+      field :something, types.String do
+        argument "flagged", types.Int, metadata_flag: :flag_1
+      end
+    end
+
+    arg = type.fields["something"].arguments["flagged"]
+    assert_equal true, arg.metadata[:flag_1]
+  end
+
   it "accepts proc type" do
     argument = GraphQL::Argument.define(name: :favoriteFood, type: -> { GraphQL::STRING_TYPE })
     assert_equal GraphQL::STRING_TYPE, argument.type
@@ -56,6 +68,14 @@ describe GraphQL::Argument do
       arg_3 = arg_2.redefine { as :ff }
       assert_equal arg_3.expose_as, "ff"
     end
+
+    it "can be set in the passed block" do
+      argument = GraphQL::Argument.define do
+        name "arg"
+        as "arg_name"
+      end
+      assert_equal "arg_name", argument.as
+    end
   end
 
   describe "prepare" do
@@ -69,5 +89,14 @@ describe GraphQL::Argument do
       argument = GraphQL::Argument.define(name: :someNumber, type: GraphQL::INT_TYPE)
       assert_equal argument.prepare(1, nil), 1
     end
+
+    it "can be set in the passed block" do
+      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
+      argument = GraphQL::Argument.define do
+        name "arg"
+        prepare prepare_proc
+      end
+      assert_equal argument.prepare(1, {val: 1}), 2
+    end
   end
 end

data/spec/graphql/define/assign_argument_spec.rb

@@ -24,17 +24,17 @@ describe GraphQL::Define::AssignArgument do
   end
 
   it "passing unknown keyword arguments will raise" do
-    err = assert_raises ArgumentError do
+    err = assert_raises GraphQL::Define::NoDefinitionError do
       define_argument(:a, GraphQL::STRING_TYPE, blah: nil)
     end
 
-    assert_equal 'unknown keyword: blah', err.message
+    assert_equal "GraphQL::Argument can't define 'blah'", err.message
 
-    err = assert_raises ArgumentError do
+    err = assert_raises GraphQL::Define::NoDefinitionError do
       define_argument(:a, GraphQL::STRING_TYPE, blah: nil, blah2: nil)
     end
 
-    assert_equal 'unknown keywords: blah, blah2', err.message
+    assert_equal "GraphQL::Argument can't define 'blah'", err.message
   end
 
   def define_argument(*args)

data/spec/graphql/define/instance_definable_spec.rb

@@ -185,7 +185,7 @@ describe GraphQL::Define::InstanceDefinable do
 
   describe "typos" do
     it "provides the right class name, method name and line number" do
-      err = assert_raises(NoMethodError) {
+      err = assert_raises(GraphQL::Define::NoDefinitionError) {
         beet = Garden::Vegetable.define {
           name "Beet"
           nonsense :Blah

data/spec/graphql/enum_type_spec.rb

@@ -110,4 +110,12 @@ describe GraphQL::EnumType do
       assert_equal(7, enum_2.values.size)
     end
   end
+
+  describe "validates enum value name uniqueness" do
+    it "raises an exception when adding a duplicate enum value name" do
+      assert_raises "Enum value names must be unique. `COW` already exists." do
+        enum.add_value(GraphQL::EnumType::EnumValue.define(name: "COW"))
+      end
+    end
+  end
 end

data/spec/graphql/execution/lazy_spec.rb

@@ -17,12 +17,24 @@ describe GraphQL::Execution::Lazy do
           value
           nestedSum(value: 7) {
             value
+            nestedSum(value: 1) {
+              value
+              nestedSum(value: -50) {
+                value
+              }
+            }
           }
         }
         b: nestedSum(value: 2) {
           value
           nestedSum(value: 11) {
             value
+            nestedSum(value: 2) {
+              value
+              nestedSum(value: -50) {
+                value
+              }
+            }
           }
         }
 
@@ -35,9 +47,24 @@ describe GraphQL::Execution::Lazy do
       |
 
       expected_data = {
-        "a"=>{"value"=>14, "nestedSum"=>{"value"=>46}},
-        "b"=>{"value"=>14, "nestedSum"=>{"value"=>46}},
-        "c"=>[{"nestedSum"=>{"value"=>14}}, {"nestedSum"=>{"value"=>14}}],
+        "a"=>{"value"=>14, "nestedSum"=>{
+          "value"=>46,
+          "nestedSum"=>{
+            "value"=>95,
+            "nestedSum"=>{"value"=>90}
+          }
+        }},
+        "b"=>{"value"=>14, "nestedSum"=>{
+          "value"=>46,
+          "nestedSum"=>{
+            "value"=>95,
+            "nestedSum"=>{"value"=>90}
+          }
+        }},
+        "c"=>[
+          {"nestedSum"=>{"value"=>14}},
+          {"nestedSum"=>{"value"=>14}}
+        ],
       }
 
       assert_equal expected_data, res["data"]

data/spec/graphql/interface_type_spec.rb

@@ -93,4 +93,48 @@ describe GraphQL::InterfaceType do
       assert_equal 4, interface_2.fields.size
     end
   end
+
+  describe "#resolve_type" do
+    let(:result) { Dummy::Schema.execute(query_string) }
+    let(:query_string) {%|
+      {
+        allEdible {
+          __typename
+          ... on Milk {
+            milkFatContent: fatContent
+          }
+          ... on Cheese {
+            cheeseFatContent: fatContent
+          }
+        }
+
+        allEdibleAsMilk {
+          __typename
+          ... on Milk {
+            fatContent
+          }
+        }
+      }
+    |}
+
+    it 'returns correct types for general schema and specific interface' do
+      expected_result = {
+        # Uses schema-level resolve_type
+        "allEdible"=>[
+          {"__typename"=>"Cheese", "cheeseFatContent"=>0.19},
+          {"__typename"=>"Cheese", "cheeseFatContent"=>0.3},
+          {"__typename"=>"Cheese", "cheeseFatContent"=>0.065},
+          {"__typename"=>"Milk", "milkFatContent"=>0.04}
+        ],
+        # Uses type-level resolve_type
+        "allEdibleAsMilk"=>[
+          {"__typename"=>"Milk", "fatContent"=>0.19},
+          {"__typename"=>"Milk", "fatContent"=>0.3},
+          {"__typename"=>"Milk", "fatContent"=>0.065},
+          {"__typename"=>"Milk", "fatContent"=>0.04}
+        ]
+      }
+      assert_equal expected_result, result["data"]
+    end
+  end
 end

data/spec/graphql/introspection/schema_type_spec.rb

@@ -19,8 +19,11 @@ describe GraphQL::Introspection::SchemaType do
         "types" => Dummy::Schema.types.values.map { |t| t.name.nil? ? (p t; raise("no name for #{t}")) : {"name" => t.name} },
         "queryType"=>{
           "fields"=>[
+            {"name"=>"allAnimal"},
+            {"name"=>"allAnimalAsCow"},
             {"name"=>"allDairy"},
             {"name"=>"allEdible"},
+            {"name"=>"allEdibleAsMilk"},
             {"name"=>"cheese"},
             {"name"=>"cow"},
             {"name"=>"dairy"},

data/spec/graphql/introspection/type_type_spec.rb

@@ -41,6 +41,7 @@ describe GraphQL::Introspection::TypeType do
       "milkType"=>{
         "interfaces"=>[
           {"name"=>"Edible"},
+          {"name"=>"EdibleAsMilk"},
           {"name"=>"AnimalProduct"},
           {"name"=>"LocalProduct"},
         ],

data/spec/graphql/object_type_spec.rb

@@ -17,7 +17,12 @@ describe GraphQL::ObjectType do
 
   describe "interfaces" do
     it "may have interfaces" do
-      assert_equal([Dummy::EdibleInterface, Dummy::AnimalProductInterface, Dummy::LocalProductInterface], type.interfaces)
+      assert_equal([
+        Dummy::EdibleInterface,
+        Dummy::EdibleAsMilkInterface,
+        Dummy::AnimalProductInterface,
+        Dummy::LocalProductInterface
+      ], type.interfaces)
     end
 
     it "raises if the interfaces arent an array" do
@@ -129,8 +134,8 @@ describe GraphQL::ObjectType do
 
       type_2.fields["nonsense"] = GraphQL::Field.define(name: "nonsense", type: type)
 
-      assert_equal 3, type.interfaces.size
-      assert_equal 4, type_2.interfaces.size
+      assert_equal 4, type.interfaces.size
+      assert_equal 5, type_2.interfaces.size
       assert_equal 8, type.fields.size
       assert_equal 9, type_2.fields.size
     end