graphql 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54eddb1e7e7ebdbe1ada0ab8286bda07a4141ebc
-  data.tar.gz: d9cc5078d078b0d9d8eded46a17ae224d33b738c
+  metadata.gz: 5e3922b4ba691948512f6936a9ebf5438e468698
+  data.tar.gz: 9162e5e2f437fc323e733a7682dd44dae9bb8cc8
 SHA512:
-  metadata.gz: f918ba8ec64d8e3157d454ef76002b4087644fcb1f92a50821f5fd189f40806b4daec24d27049c022a59c27dc9a698742ad099546ce53b20645a7e0f6ebd8c28
-  data.tar.gz: 21140eaea9b18fd8405cb195f67d8f380d08dbf7d537e191c4672bd65240b1f589074927e0a62951f6506eaf0762efcd351e35b0e7951c4012b3552d70b747e0
+  metadata.gz: 1c3763c608645843eaffaa81d95e29d019008209b1af2f91a06d35431403114a4b60feebfec3e7659db45b05695e7a4ce3c67012f573ca4e4283ecc12a2186c3
+  data.tar.gz: 08e82e3316840ebaeeb63aee2e73d8909ae863634c00d6eec38e03ba8a2a2038239f1e4ef694af70f952599aafc6d6bd3f1623741ebb0b7d61e3d8f43765c21e

data/lib/graphql/introspection/schema_type.rb

@@ -10,15 +10,15 @@ GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
   end
 
   field :queryType, !GraphQL::Introspection::TypeType, "The type that query operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { obj.query }
+    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("query") }
   end
 
   field :mutationType, GraphQL::Introspection::TypeType, "If this server supports mutation, the type that mutation operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { obj.mutation }
+    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("mutation") }
   end
 
   field :subscriptionType, GraphQL::Introspection::TypeType, "If this server support subscription, the type that subscription operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { obj.subscription }
+    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("subscription") }
   end
 
   field :directives, !types[!GraphQL::Introspection::DirectiveType], "A list of all directives supported by this server." do

data/lib/graphql/language/nodes.rb

@@ -319,7 +319,7 @@ module GraphQL
         scalar_attributes :name, :type, :default_value
 
         # @!attribute default_value
-        #   @return [String, Integer, Float, Boolean, Array] A Ruby value to use if no other value is provided
+        #   @return [String, Integer, Float, Boolean, Array, NullValue] A Ruby value to use if no other value is provided
 
         # @!attribute type
         #   @return [TypeName, NonNullType, ListType] The expected type of this value

data/lib/graphql/query.rb

@@ -11,6 +11,8 @@ require "graphql/query/variable_validation_error"
 module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
+    extend Forwardable
+
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(names)
         msg = "You must provide an operation name from: #{names.join(", ")}"
@@ -34,13 +36,7 @@ module GraphQL
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
       @schema = schema
-      mask = if except
-        wrap_if_legacy_mask(except)
-      elsif only
-        InvertedMask.new(wrap_if_legacy_mask(only))
-      else
-        schema.default_mask
-      end
+      mask = MergedMask.combine(schema.default_mask, except: except, only: only)
       @context = Context.new(query: self, values: context)
       @warden = GraphQL::Schema::Warden.new(mask, schema: @schema, context: @context)
       @max_depth = max_depth || schema.max_depth
@@ -202,18 +198,8 @@ module GraphQL
       @valid
     end
 
-    def get_type(type_name)
-      @warden.get_type(type_name)
-    end
+    def_delegators :@warden, :get_type, :get_field, :possible_types, :root_type_for_operation
 
-    def get_field(type, name)
-      @fields ||= Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = @warden.get_field(k, k2) } }
-      @fields[type][name]
-    end
-
-    def possible_types(type)
-      @warden.possible_types(type)
-    end
 
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}
@@ -262,15 +248,6 @@ module GraphQL
       end
     end
 
-    def wrap_if_legacy_mask(mask)
-      if (mask.is_a?(Proc) && mask.arity == 1) || mask.method(:call).arity == 1
-        warn("Schema.execute(..., except:) filters now accept two arguments, `(member, ctx)`. One-argument filters are deprecated.")
-        LegacyMaskWrap.new(mask)
-      else
-        mask
-      end
-    end
-
     # @api private
     class InvertedMask
       def initialize(inner_mask)
@@ -294,5 +271,40 @@ module GraphQL
         @inner_mask.call(member)
       end
     end
+
+    # @api private
+    class MergedMask
+      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
+
+      def self.combine(default_mask, except:, only:)
+        query_mask = if except
+          wrap_if_legacy_mask(except)
+        elsif only
+          InvertedMask.new(wrap_if_legacy_mask(only))
+        end
+
+        if query_mask && (default_mask != GraphQL::Schema::NullMask)
+          self.new(default_mask, query_mask)
+        else
+          query_mask || default_mask
+        end
+      end
+
+      def self.wrap_if_legacy_mask(mask)
+        if (mask.is_a?(Proc) && mask.arity == 1) || mask.method(:call).arity == 1
+          warn("Schema.execute(..., except:) filters now accept two arguments, `(member, ctx)`. One-argument filters are deprecated.")
+          LegacyMaskWrap.new(mask)
+        else
+          mask
+        end
+      end
+    end
   end
 end

data/lib/graphql/query/executor.rb

@@ -28,7 +28,7 @@ module GraphQL
         return {} if operation.nil?
 
         op_type = operation.operation_type
-        root_type = query.schema.root_type_for_operation(op_type)
+        root_type = query.root_type_for_operation(op_type)
         execution_strategy_class = query.schema.execution_strategy_for_operation(op_type)
         execution_strategy = execution_strategy_class.new
 

data/lib/graphql/query/variables.rb

@@ -14,38 +14,31 @@ module GraphQL
         @provided_variables = provided_variables
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
+          # Find the right value for this variable:
+          # - First, use the value provided at runtime
+          # - 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
-          memo[variable_name] = get_graphql_value(ast_variable)
-        end
-      end
-
-      def [](key)
-        @storage.fetch(key)
-      end
+          default_value = ast_variable.default_value
+          provided_value = @provided_variables[variable_name]
+          value_was_provided = @provided_variables.key?(variable_name)
 
-      def_delegators :@storage, :length
-
-      private
-
-      # Find the right value for this variable:
-      # - First, use the value provided at runtime
-      # - Then, fall back to the default value from the query string
-      # If it's still nil, raise an error if it's required.
-      def get_graphql_value(ast_variable)
-        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]
-
-        validation_result = variable_type.validate_input(provided_value, @warden)
-        if !validation_result.valid?
-          @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-        elsif !@provided_variables.key?(variable_name) && provided_value.nil?
-          GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
-        else
-          variable_type.coerce_input(provided_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
+
+      def_delegators :@storage, :length, :key?, :[], :fetch
     end
   end
 end

data/lib/graphql/relay/connection_type.rb

@@ -13,9 +13,11 @@ module GraphQL
         edge_type ||= wrapped_type.edge_type
         edge_class ||= GraphQL::Relay::Edge
         connection_type_name = "#{wrapped_type.name}Connection"
+        connection_type_description = "The connection type for #{wrapped_type.name}."
 
         connection_type = ObjectType.define do
           name(connection_type_name)
+          description(connection_type_description)
           field :edges, types[edge_type] do
             description "A list of edges."
             resolve ->(obj, args, ctx) {

data/lib/graphql/relay/relation_connection.rb

@@ -17,7 +17,7 @@ module GraphQL
       end
 
       def has_next_page
-        !!(first && sliced_nodes.limit(limit + 1).count > limit)
+        !!(first && count(sliced_nodes.limit(limit + 1)) > limit)
       end
 
       def has_previous_page
@@ -26,6 +26,12 @@ module GraphQL
 
       private
 
+      # If a relation contains a `.group` clause, a `.count` will return a Hash.
+      def count(nodes)
+        count_or_hash = nodes.count
+        count_or_hash.is_a?(Integer) ? count_or_hash : count_or_hash.length
+      end
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= sliced_nodes.limit(limit)
@@ -45,7 +51,7 @@ module GraphQL
           if before
             [previous_offset, 0].max
           elsif last
-            nodes.count - last
+            count(nodes) - last
           else
             previous_offset
           end

data/lib/graphql/schema.rb

@@ -215,6 +215,9 @@ 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)
       case operation
       when "query"

data/lib/graphql/schema/warden.rb

@@ -120,6 +120,15 @@ module GraphQL
         @schema.directives.each_value.select { |d| visible?(d) }
       end
 
+      def root_type_for_operation(op_name)
+        root_type = @schema.root_type_for_operation(op_name)
+        if root_type && visible?(root_type)
+          root_type
+        else
+          nil
+        end
+      end
+
       private
 
       def visible_field?(field_defn)

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

@@ -5,7 +5,7 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        return if context.schema.mutation
+        return if context.warden.root_type_for_operation("mutation")
 
         visitor = context.visitor
 

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

@@ -5,7 +5,7 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        return if context.schema.subscription
+        return if context.warden.root_type_for_operation("subscription")
 
         visitor = context.visitor
 

data/lib/graphql/version.rb

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

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -28,7 +28,7 @@ describe GraphQL::Analysis do
     let(:analyzers) { [type_collector, node_counter] }
     let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
     let(:variables) { {} }
-    let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
     let(:query_string) {%|
       {
         cheese(id: 1) {
@@ -40,7 +40,7 @@ describe GraphQL::Analysis do
 
     it "calls the defined analyzers" do
       collected_types, node_counts = reduce_result
-      expected_visited_types = [DairyAppQueryType, CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
+      expected_visited_types = [Dummy::DairyAppQueryType, Dummy::CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
       assert_equal expected_visited_types, collected_types
       expected_node_counts = {
         GraphQL::Language::Nodes::OperationDefinition => 1,
@@ -61,14 +61,14 @@ describe GraphQL::Analysis do
       let(:variable_accessor) { ->(memo, visit_type, irep_node) { query.variables["cheeseId"] } }
 
       before do
-        @previous_query_analyzers = DummySchema.query_analyzers.dup
-        DummySchema.query_analyzers.clear
-        DummySchema.query_analyzers << variable_accessor
+        @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
+        Dummy::Schema.query_analyzers.clear
+        Dummy::Schema.query_analyzers << variable_accessor
       end
 
       after do
-        DummySchema.query_analyzers.clear
-        DummySchema.query_analyzers.push(*@previous_query_analyzers)
+        Dummy::Schema.query_analyzers.clear
+        Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
       end
 
       it "returns an error" do
@@ -97,7 +97,7 @@ describe GraphQL::Analysis do
       }
       let(:analyzers) { [connection_counter] }
       let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-      let(:query) { GraphQL::Query.new(StarWarsSchema, query_string, variables: variables) }
+      let(:query) { GraphQL::Query.new(StarWars::Schema, query_string, variables: variables) }
       let(:query_string) {%|
         query getBases {
           empire {
@@ -155,7 +155,7 @@ describe GraphQL::Analysis do
     let(:flavor_catcher) { FlavorCatcher.new }
     let(:analyzers) { [id_catcher, flavor_catcher] }
     let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
     let(:query_string) {%|
       {
         cheese(id: 1) {
@@ -164,7 +164,7 @@ describe GraphQL::Analysis do
         }
       }
     |}
-    let(:schema) { DummySchema }
+    let(:schema) { Dummy::Schema }
     let(:result) { schema.execute(query_string) }
     let(:query_string) {%|
       {
@@ -176,14 +176,14 @@ describe GraphQL::Analysis do
     |}
 
     before do
-      @previous_query_analyzers = DummySchema.query_analyzers.dup
-      DummySchema.query_analyzers.clear
-      DummySchema.query_analyzers << id_catcher << flavor_catcher
+      @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
+      Dummy::Schema.query_analyzers.clear
+      Dummy::Schema.query_analyzers << id_catcher << flavor_catcher
     end
 
     after do
-      DummySchema.query_analyzers.clear
-      DummySchema.query_analyzers.push(*@previous_query_analyzers)
+      Dummy::Schema.query_analyzers.clear
+      Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
     end
 
     it "groups all errors together" do

data/spec/graphql/analysis/field_usage_spec.rb

@@ -5,7 +5,7 @@ describe GraphQL::Analysis::FieldUsage do
   let(:result) { [] }
   let(:field_usage_analyzer) { GraphQL::Analysis::FieldUsage.new { |query, used_fields, used_deprecated_fields| result << query << used_fields << used_deprecated_fields } }
   let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [field_usage_analyzer]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
   let(:variables) { {} }
 
   describe "query with deprecated fields" do

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -3,15 +3,15 @@ require "spec_helper"
 
 describe GraphQL::Analysis::MaxQueryComplexity do
   before do
-    @prev_max_complexity = DummySchema.max_complexity
+    @prev_max_complexity = Dummy::Schema.max_complexity
   end
 
   after do
-    DummySchema.max_complexity = @prev_max_complexity
+    Dummy::Schema.max_complexity = @prev_max_complexity
   end
 
 
-  let(:result) { DummySchema.execute(query_string) }
+  let(:result) { Dummy::Schema.execute(query_string) }
   let(:query_string) {%|
     {
       a: cheese(id: 1) { id }
@@ -24,7 +24,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when a query goes over max complexity" do
     before do
-      DummySchema.max_complexity = 9
+      Dummy::Schema.max_complexity = 9
     end
 
     it "returns an error" do
@@ -34,7 +34,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when there is no max complexity" do
     before do
-      DummySchema.max_complexity = nil
+      Dummy::Schema.max_complexity = nil
     end
     it "doesn't error" do
       assert_equal nil, result["errors"]
@@ -43,7 +43,7 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when the query is less than the max complexity" do
     before do
-      DummySchema.max_complexity = 99
+      Dummy::Schema.max_complexity = 99
     end
     it "doesn't error" do
       assert_equal nil, result["errors"]
@@ -52,9 +52,9 @@ describe GraphQL::Analysis::MaxQueryComplexity do
 
   describe "when complexity is overriden at query-level" do
     before do
-      DummySchema.max_complexity = 100
+      Dummy::Schema.max_complexity = 100
     end
-    let(:result) { DummySchema.execute(query_string, max_complexity: 7) }
+    let(:result) { Dummy::Schema.execute(query_string, max_complexity: 7) }
 
     it "is applied" do
       assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result["errors"][0]["message"]