graphql 1.5.3 → 1.5.4

data/lib/graphql/query/variables.rb

@@ -19,21 +19,25 @@ module GraphQL
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
           variable_type = @schema.type_from_ast(ast_variable.type)
-          variable_name = ast_variable.name
-          default_value = ast_variable.default_value
-          provided_value = @provided_variables[variable_name]
-          value_was_provided = @provided_variables.key?(variable_name)
+          if variable_type.nil?
+            # Pass -- it will get handled by a validator
+          else
+            variable_name = ast_variable.name
+            default_value = ast_variable.default_value
+            provided_value = @provided_variables[variable_name]
+            value_was_provided = @provided_variables.key?(variable_name)
 
-          validation_result = variable_type.validate_input(provided_value, @warden)
-          if !validation_result.valid?
-            # This finds variables that were required but not provided
-            @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-          elsif value_was_provided
-            # Add the variable if a value was provided
-            memo[variable_name] = variable_type.coerce_input(provided_value)
-          elsif default_value
-            # Add the variable if it wasn't provided but it has a default value (including `null`)
-            memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
+            validation_result = variable_type.validate_input(provided_value, @warden)
+            if !validation_result.valid?
+              # This finds variables that were required but not provided
+              @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
+            elsif value_was_provided
+              # Add the variable if a value was provided
+              memo[variable_name] = variable_type.coerce_input(provided_value)
+            elsif default_value
+              # Add the variable if it wasn't provided but it has a default value (including `null`)
+              memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
+            end
           end
         end
       end

data/lib/graphql/schema.rb

@@ -6,6 +6,7 @@ require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
+require "graphql/schema/mask"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
@@ -212,11 +213,11 @@ module GraphQL
       if defined_field
         defined_field
       elsif field_name == "__typename"
-        GraphQL::Introspection::TypenameField.create(parent_type)
+        GraphQL::Introspection::TypenameField
       elsif field_name == "__schema" && parent_type == query
-        GraphQL::Introspection::SchemaField.create(self)
+        GraphQL::Introspection::SchemaField
       elsif field_name == "__type" && parent_type == query
-        GraphQL::Introspection::TypeByNameField.create(self)
+        GraphQL::Introspection::TypeByNameField
       else
         nil
       end

data/lib/graphql/schema/mask.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Tools for working with schema masks (`only` / `except`).
+    #
+    # In general, these are functions which, when they return `true`,
+    # the `member` is hidden for the current query.
+    #
+    # @api private
+    module Mask
+      module_function
+
+      # Combine a schema's default_mask with query-level masks.
+      def combine(default_mask, except:, only:)
+        query_mask = if except
+          except
+        elsif only
+          InvertedMask.new(only)
+        end
+
+        if query_mask && (default_mask != GraphQL::Schema::NullMask)
+          EitherMask.new(default_mask, query_mask)
+        else
+          query_mask || default_mask
+        end
+      end
+
+      # @api private
+      # Returns true when the inner mask returned false
+      # Returns false when the inner mask returned true
+      class InvertedMask
+        def initialize(inner_mask)
+          @inner_mask = inner_mask
+        end
+
+        def call(member, ctx)
+          !@inner_mask.call(member, ctx)
+        end
+      end
+
+      # Hides `member` if _either_ mask would hide the member.
+      # @api private
+      class EitherMask
+        def initialize(first_mask, second_mask)
+          @first_mask = first_mask
+          @second_mask = second_mask
+        end
+
+        def call(member, ctx)
+          @first_mask.call(member, ctx) || @second_mask.call(member, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/possible_types.rb

@@ -26,10 +26,10 @@ module GraphQL
           type_defn.possible_types
         when GraphQL::InterfaceType
           @interface_implementers[type_defn]
-        when GraphQL::ObjectType
+        when GraphQL::BaseType
           [type_defn]
         else
-          raise "#{type_defn} doesn't have possible types"
+          raise "Unexpected possible_types object: #{type_defn}"
         end
       end
     end

data/lib/graphql/schema/type_expression.rb

@@ -1,18 +1,33 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
+    # @api private
     module TypeExpression
+      # Fetch a type from a type map by its AST specification.
+      # Return `nil` if not found.
+      # @param types [GraphQL::Schema::TypeMap]
+      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+      # @return [GraphQL::BaseType, nil]
       def self.build_type(types, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          type_name = ast_node.name
-          types[type_name]
+          types.fetch(ast_node.name, nil)
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
-          build_type(types, ast_inner_type).to_non_null_type
+          inner_type = build_type(types, ast_inner_type)
+          wrap_type(inner_type, GraphQL::NonNullType)
         when GraphQL::Language::Nodes::ListType
           ast_inner_type = ast_node.of_type
-          build_type(types, ast_inner_type).to_list_type
+          inner_type = build_type(types, ast_inner_type)
+          wrap_type(inner_type, GraphQL::ListType)
+        end
+      end
+
+      def self.wrap_type(type, wrapper)
+        if type.nil?
+          nil
+        else
+          wrapper.new(of_type: type)
         end
       end
     end

data/lib/graphql/schema/warden.rb

@@ -43,9 +43,8 @@ module GraphQL
       # @param schema [GraphQL::Schema]
       # @param deep_check [Boolean]
       def initialize(mask, context:, schema:)
-        @mask = mask
-        @context = context
         @schema = schema
+        @visibility_cache = read_through { |m| !mask.call(m, context) }
       end
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema
@@ -136,7 +135,6 @@ module GraphQL
       end
 
       def visible?(member)
-        @visibility_cache ||= read_through { |m| !@mask.call(m, @context) }
         @visibility_cache[member]
       end
 

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

@@ -5,10 +5,11 @@ module GraphQL
       def validate(context)
         context.each_irep_node do |node|
           if node.ast_nodes.size > 1
+            defn_names = Set.new(node.ast_nodes.map(&:name))
 
             # Check for more than one GraphQL::Field backing this node:
-            if node.definitions.size > 1
-              defn_names = node.definitions.map { |d| d.name }.sort.join(" or ")
+            if defn_names.size > 1
+              defn_names = defn_names.sort.join(" or ")
               msg = "Field '#{node.name}' has a field conflict: #{defn_names}?"
               context.errors << GraphQL::StaticValidation::Message.new(msg, nodes: node.ast_nodes.to_a)
             end

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

@@ -43,8 +43,10 @@ module GraphQL
           # It's not a valid fragment type, this error was handled someplace else
           return
         end
-        intersecting_types = context.warden.possible_types(parent_type.unwrap) & context.warden.possible_types(child_type.unwrap)
-        if intersecting_types.none?
+        parent_types = context.warden.possible_types(parent_type.unwrap)
+        child_types = context.warden.possible_types(child_type.unwrap)
+
+        if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
           context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node, path: path)
         end

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

@@ -18,7 +18,9 @@ module GraphQL
           context.errors << message("Non-null variable $#{node.name} can't have a default value", node, context: context)
         else
           type = context.schema.type_from_ast(node.type)
-          if !context.valid_literal?(value, type)
+          if type.nil?
+            # This is handled by another validator
+          elsif !context.valid_literal?(value, type)
             context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node, context: context)
           end
         end

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

@@ -33,7 +33,7 @@ module GraphQL
       private
 
       def validate_usage(arguments, arg_node, ast_var, context)
-        var_type = to_query_type(ast_var.type, context.query.warden)
+        var_type = context.schema.type_from_ast(ast_var.type)
         if var_type.nil?
           return
         end
@@ -56,25 +56,6 @@ module GraphQL
         end
       end
 
-      def to_query_type(ast_type, warden)
-        case ast_type
-        when GraphQL::Language::Nodes::NonNullType
-          wrap_query_type(to_query_type(ast_type.of_type, warden), GraphQL::NonNullType)
-        when GraphQL::Language::Nodes::ListType
-          wrap_query_type(to_query_type(ast_type.of_type, warden), GraphQL::ListType)
-        else
-          warden.get_type(ast_type.name)
-        end
-      end
-
-      def wrap_query_type(type, wrapper)
-        if type.nil?
-          nil
-        else
-          wrapper.new(of_type: type)
-        end
-      end
-
       def create_error(error_message, var_type, ast_var, arg_defn, arg_node, context)
         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

data/lib/graphql/static_validation/validation_context.rb

@@ -12,28 +12,17 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
+      extend Forwardable
+
       attr_reader :query, :schema,
         :document, :errors, :visitor,
-        :fragments, :operations, :warden,
-        :dependencies, :each_irep_node_handlers
+        :warden, :dependencies, :each_irep_node_handlers
+
+      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
       def initialize(query)
         @query = query
-        @schema = query.schema
-        @document = query.document
-        @fragments = {}
-        @operations = {}
-        @warden = query.warden
-
-        document.definitions.each do |definition|
-          case definition
-          when GraphQL::Language::Nodes::FragmentDefinition
-            @fragments[definition.name] = definition
-          when GraphQL::Language::Nodes::OperationDefinition
-            @operations[definition.name] = definition
-          end
-        end
-
+        @literal_validator = LiteralValidator.new(warden: warden)
         @errors = []
         @visitor = GraphQL::Language::Visitor.new(document)
         @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
@@ -93,7 +82,6 @@ module GraphQL
       end
 
       def valid_literal?(ast_value, type)
-        @literal_validator ||= LiteralValidator.new(warden: @warden)
         @literal_validator.validate(ast_value, type)
       end
     end

data/lib/graphql/version.rb

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

data/spec/graphql/enum_type_spec.rb

@@ -67,6 +67,18 @@ describe GraphQL::EnumType do
     end
   end
 
+  it "accepts a symbol as a variant and Ruby-land value" do
+    enum = GraphQL::EnumType.define do
+      name 'MessageFormat'
+      value :markdown
+    end
+
+    variant = enum.values['markdown']
+
+    assert_equal(variant.name, 'markdown')
+    assert_equal(variant.value, :markdown)
+  end
+
   it "has value description" do
     assert_equal("Animal with horns", enum.values["GOAT"].description)
   end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -59,7 +59,6 @@ describe GraphQL::InternalRepresentation::Rewrite do
     res[:errors].any? && raise(res[:errors].map(&:message).join("; "))
     res[:irep]
   }
-  # TODO: make sure all rewrite specs are covered
 
   describe "building a tree over concrete types with fragments" do
     let(:query_string) {
@@ -107,6 +106,9 @@ describe GraphQL::InternalRepresentation::Rewrite do
     it "groups selections by object types which they apply to" do
       doc = rewrite_result["getPlant"]
 
+      plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
+      assert_equal ["Fruit", "Nut", "Plant", "Tree"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
+
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       assert_equal ["Fruit", "Grain", "Nut", "Vegetable"], plant_selection.typed_children.keys.map(&:name).sort
 
@@ -121,6 +123,25 @@ describe GraphQL::InternalRepresentation::Rewrite do
       habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
       assert_equal ["averageWeight", "seasons"], habitats_selections.keys
     end
+
+    it "tracks parent nodes" do
+      doc = rewrite_result["getPlant"]
+      assert_equal nil, doc.parent
+
+      plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
+      assert_equal doc, plant_selection.parent
+
+      leaf_type_selection = plant_selection.typed_children[schema.types["Nut"]]["leafType"]
+      assert_equal plant_selection, leaf_type_selection.parent
+
+      habitats_selection = plant_selection.typed_children[schema.types["Nut"]]["habitats"]
+      assert_equal plant_selection, habitats_selection.parent
+
+      seasons_selection = habitats_selection.typed_children[schema.types["Habitat"]]["seasons"]
+      average_weight_selection = habitats_selection.typed_children[schema.types["Habitat"]]["averageWeight"]
+      assert_equal habitats_selection, seasons_selection.parent
+      assert_equal habitats_selection, average_weight_selection.parent
+    end
   end
 
   describe "tracking directives on fragment spreads" do
@@ -253,14 +274,14 @@ describe GraphQL::InternalRepresentation::Rewrite do
       assert_equal 3, cheeses.length
       assert_equal 1, milks.length
 
-      expected_cheese_fields = ["cheeseInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin", "cheeseFragmentOrigin"]
+      expected_cheese_fields = ["cheeseFragmentOrigin", "cheeseInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin"]
       cheeses.each do |cheese|
-        assert_equal expected_cheese_fields, cheese["selfAsEdible"].keys
+        assert_equal expected_cheese_fields, cheese["selfAsEdible"].keys.sort
       end
 
-      expected_milk_fields = ["milkInlineOrigin", "edibleInlineOrigin", "untypedInlineOrigin", "milkFragmentOrigin"]
+      expected_milk_fields = ["edibleInlineOrigin", "milkFragmentOrigin", "milkInlineOrigin", "untypedInlineOrigin"]
       milks.each do |milk|
-        assert_equal expected_milk_fields, milk["selfAsEdible"].keys
+        assert_equal expected_milk_fields, milk["selfAsEdible"].keys.sort
       end
     end
   end

data/spec/graphql/query_spec.rb

@@ -401,16 +401,36 @@ describe GraphQL::Query do
     end
   end
 
-  describe "#max_depth" do
+  describe "max_depth" do
+    let(:query_string) {
+      <<-GRAPHQL
+      {
+        cheese(id: 1) {
+          similarCheese(source: SHEEP) {
+            similarCheese(source: SHEEP) {
+              similarCheese(source: SHEEP) {
+                similarCheese(source: SHEEP) {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+      GRAPHQL
+    }
+
     it "defaults to the schema's max_depth" do
-      assert_equal 5, query.max_depth
+      # Constrained by schema's setting of 5
+      assert_equal 1, result["errors"].length
     end
 
     describe "overriding max_depth" do
       let(:max_depth) { 12 }
 
       it "overrides the schema's max_depth" do
-        assert_equal 12, query.max_depth
+        assert result["data"].key?("cheese")
+        assert_equal nil, result["errors"]
       end
     end
   end

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -559,7 +559,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           }
         }
         fragment X on SomeBox {
-          scalar
+          scalar: deepBox { unreleatedField }
         }
         fragment Y on SomeBox {
           scalar: unrelatedField
@@ -567,7 +567,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
       |}
 
       it "fails rule" do
-        assert_includes error_messages, "Field 'scalar' has a field conflict: scalar or unrelatedField?"
+        assert_includes error_messages, "Field 'scalar' has a field conflict: deepBox or unrelatedField?"
       end
     end
   end