graphql 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7468a99f3a243670d95dc1b6423d6de98aeacd20
-  data.tar.gz: ac2dd7a0264557a07349df7a5a7c84eca070d27c
+  metadata.gz: dcc96523b4e6938e39aeae90c15728985618c95b
+  data.tar.gz: da73ad353f7891bf9f4146e8941200747a928c39
 SHA512:
-  metadata.gz: 43b4b7f8618b984e00f6c646d3ed547f2cdbc0417ea83c8bed1461d10482d48ade39938facde49636c7f73f945b360eb964516bd8eeb648b03af4941db0098f1
-  data.tar.gz: a82abfa0257bae1387fffb3fb06eead5010236b4670c9093db38e0343f81b9bccb08a3140887f4a109be67da773eb97593b669752cb17b124494bdf555fd27c4
+  metadata.gz: b709b3b6833dd60102f6bfa7ebc7efd7a1a36ef7af8b0aa5723b1b421cc4c14516ef2480d058c885d9fb9de34013c0e3d0e6d0bbaa22850df7ff2bf9c50535c8
+  data.tar.gz: 0a4b99378090cfbce6916a725ccadb8b91238cbeaf8a00c28e0fcbcedc43d1b8c238b3f2c502ece948e5379a2d33cb2265e8210c2e44ae466d570f177fb44059

data/lib/graphql/execution/multiplex.rb

@@ -40,7 +40,27 @@ module GraphQL
           run_queries(schema, queries, *rest)
         end
 
+        # @param schema [GraphQL::Schema]
+        # @param queries [Array<GraphQL::Query>]
+        # @param context [Hash]
+        # @param max_complexity [Integer]
+        # @return [Array<Hash>] One result per query
         def run_queries(schema, queries, context: {}, max_complexity: nil)
+          has_custom_strategy = schema.query_execution_strategy || schema.mutation_execution_strategy || schema.subscription_execution_strategy
+          if has_custom_strategy
+            if queries.length == 1
+              return [run_one_legacy(schema, queries.first)]
+            else
+              raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
+            end
+          else
+            run_as_multiplex(schema, queries, context: context, max_complexity: max_complexity)
+          end
+        end
+
+        private
+
+        def run_as_multiplex(schema, queries, context:, max_complexity:)
           query_instrumenters = schema.instrumenters[:query]
           multiplex_instrumenters = schema.instrumenters[:multiplex]
           multiplex = self.new(schema: schema, queries: queries, context: context)
@@ -80,8 +100,6 @@ module GraphQL
           multiplex_instrumenters.reverse_each { |i| i.after_multiplex(multiplex) }
         end
 
-        private
-
         # @param query [GraphQL::Query]
         # @return [Hash] The initial result (may not be finished if there are lazy values)
         def begin_query(query)
@@ -128,6 +146,24 @@ module GraphQL
             result
           end
         end
+
+        # use the old `query_execution_strategy` etc to run this query
+        def run_one_legacy(schema, query)
+          instrumenters = schema.instrumenters[:query]
+          instrumenters.each { |i| i.before_query(query) }
+          query.result = if !query.valid?
+            all_errors = query.validation_errors + query.analysis_errors + query.context.errors
+            if all_errors.any?
+              { "errors" => all_errors.map(&:to_h) }
+            else
+              nil
+            end
+          else
+            GraphQL::Query::Executor.new(query).result
+          end
+        ensure
+          instrumenters.reverse_each { |i| i.after_query(query) }
+        end
       end
     end
   end

data/lib/graphql/query.rb

@@ -188,7 +188,11 @@ module GraphQL
     end
 
     def mutation?
-      @mutation
+      with_prepared_ast { @mutation }
+    end
+
+    def query?
+      with_prepared_ast { @query }
     end
 
     # @return [void]
@@ -260,6 +264,7 @@ module GraphQL
           end
           @ast_variables = @selected_operation.variables
           @mutation = @selected_operation.operation_type == "mutation"
+          @query = @selected_operation.operation_type == "query"
         end
       end
 

data/lib/graphql/query/executor.rb

@@ -8,7 +8,6 @@ module GraphQL
       attr_reader :query
 
       def initialize(query)
-        warn("Executor is deprecated; use Schema#execute")
         @query = query
       end
 

data/lib/graphql/relay/base_connection.rb

@@ -57,13 +57,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        @context = context
         @nodes = nodes
         @arguments = arguments
-        @max_page_size = max_page_size
         @field = field
         @parent = parent
-        @context = context
         @encoder = context ? @context.schema.cursor_encoder : GraphQL::Schema::Base64Encoder
+        @max_page_size = max_page_size.nil? && context ? @context.schema.default_max_page_size : max_page_size
       end
 
       def encode(data)

data/lib/graphql/relay/relation_connection.rb

@@ -83,19 +83,17 @@ module GraphQL
       end
 
       def relation_offset(relation)
-        case relation
-        when ActiveRecord::Relation
+        if relation.respond_to?(:offset_value)
           relation.offset_value
-        when Sequel::Dataset
+        else
           relation.opts[:offset]
         end
       end
 
       def relation_limit(relation)
-        case relation
-        when ActiveRecord::Relation
+        if relation.respond_to?(:limit_value)
           relation.limit_value
-        when Sequel::Dataset
+        else
           relation.opts[:limit]
         end
       end

data/lib/graphql/schema.rb

@@ -55,7 +55,7 @@ module GraphQL
     accepts_definitions \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity,
+      :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :raise_definition_error,
       :object_from_id, :id_from_object,
@@ -77,7 +77,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity,
+      :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -98,7 +98,7 @@ module GraphQL
       GraphQL::Filter.new(except: default_mask)
     end
 
-    self.default_execution_strategy = GraphQL::Execution::Execute
+    self.default_execution_strategy = nil
 
     BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
     DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
@@ -256,11 +256,22 @@ module GraphQL
 
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
-    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
+    # @param parent_type [String, GraphQL::BaseType]
+    # @param field_name [String]
     # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`
+    # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     def get_field(parent_type, field_name)
       with_definition_error_check do
-        defined_field = @instrumented_field_map.get(parent_type.name, field_name)
+        parent_type_name = case parent_type
+        when GraphQL::BaseType
+          parent_type.name
+        when String
+          parent_type
+        else
+          raise "Unexpected parent_type: #{parent_type}"
+        end
+
+        defined_field = @instrumented_field_map.get(parent_type_name, field_name)
         if defined_field
           defined_field
         elsif field_name == "__typename"

data/lib/graphql/schema/rescue_middleware.rb

@@ -15,18 +15,18 @@ module GraphQL
       # @example Rescue from not-found by telling the user
       #   MySchema.rescue_from(ActiveRecord::RecordNotFound) { "An item could not be found" }
       #
-      # @param error_class [Class] a class of error to rescue from
-      # @yield [err] A handler to return a message for this error instance
+      # @param error_classes [Class] one or more classes of errors to rescue from
+      # @yield [err] A handler to return a message for these error instances
       # @yieldparam [Exception] an error that was rescued
       # @yieldreturn [String] message to put in GraphQL response
-      def rescue_from(error_class, &block)
-        rescue_table[error_class] = block
+      def rescue_from(*error_classes, &block)
+        error_classes.map{ |error_class| rescue_table[error_class] = block }
       end
 
-      # Remove the handler for `error_class`
+      # Remove the handler for `error_classs`
       # @param error_class [Class] the error class whose handler should be removed
-      def remove_handler(error_class)
-        rescue_table.delete(error_class)
+      def remove_handler(*error_classes)
+        error_classes.map{ |error_class| rescue_table.delete(error_class) }
       end
 
       # Implement the requirement for {GraphQL::Schema::MiddlewareChain}

data/lib/graphql/version.rb

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

data/spec/graphql/query_spec.rb

@@ -500,6 +500,24 @@ describe GraphQL::Query do
     end
   end
 
+  describe "#mutation?" do
+    let(:query_string) { <<-GRAPHQL
+    query Q { __typename }
+    mutation M { pushValue(value: 1) }
+    GRAPHQL
+    }
+
+    it "returns true if the selected operation is a mutation" do
+      query_query = GraphQL::Query.new(schema, query_string, operation_name: "Q")
+      assert_equal false, query_query.mutation?
+      assert_equal true, query_query.query?
+
+      mutation_query = GraphQL::Query.new(schema, query_string, operation_name: "M")
+      assert_equal true, mutation_query.mutation?
+      assert_equal false, mutation_query.query?
+    end
+  end
+
   describe 'NullValue type arguments' do
     let(:schema_definition) {
       <<-GRAPHQL
@@ -578,4 +596,30 @@ describe GraphQL::Query do
       assert_kind_of GraphQL::InternalRepresentation::Node, query.internal_representation.fragment_definitions["dairyFields"]
     end
   end
+
+  describe "query_execution_strategy" do
+    let(:custom_execution_schema) { schema.redefine(query_execution_strategy: DummyStrategy) }
+
+    class DummyStrategy
+      def execute(ast_operation, root_type, query_object)
+        { "dummy" => true }
+      end
+    end
+
+    it "is used for running a query, if it's present and not the default" do
+      result = custom_execution_schema.execute(" { __typename }")
+      assert_equal({"data"=>{"dummy"=>true}}, result)
+    end
+
+    it "can't run a multiplex" do
+      err = assert_raises ArgumentError do
+        custom_execution_schema.multiplex([
+          {query: " { __typename }"},
+          {query: " { __typename }"},
+        ])
+      end
+      msg = "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
+      assert_equal msg, err.message
+    end
+  end
 end

data/spec/graphql/relay/array_connection_spec.rb

@@ -196,5 +196,65 @@ describe GraphQL::Relay::ArrayConnection do
         assert_equal(first_and_second_names, get_names(result))
       end
     end
+
+    describe "applying default_max_page_size" do
+      def get_names(result)
+        result["data"]["rebels"]["bases"]["edges"].map { |e| e["node"]["name"] }
+      end
+
+      def get_page_info(result)
+        result["data"]["rebels"]["bases"]["pageInfo"]
+      end
+
+      let(:query_string) {%|
+        query getShips($first: Int, $after: String, $last: Int, $before: String){
+          rebels {
+            bases: basesWithDefaultMaxLimitArray(first: $first, after: $after, last: $last, before: $before) {
+              edges {
+                cursor
+                node {
+                  name
+                }
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+              }
+            }
+          }
+        }
+      |}
+
+      it "applies to queries by `first`" do
+        result = star_wars_query(query_string, "first" => 100)
+        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
+        assert_equal(true, get_page_info(result)["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = star_wars_query(query_string)
+        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
+        assert_equal(false, get_page_info(result)["hasNextPage"], "hasNextPage is false when first is not specified")
+      end
+
+      it "applies to queries by `last`" do
+        last_cursor = "Ng=="
+
+        result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
+        assert_equal(["Secret Hideout", "Death Star", "Shield Generator"], get_names(result))
+        assert_equal(true, get_page_info(result)["hasPreviousPage"])
+
+        result = star_wars_query(query_string, "before" => last_cursor)
+        assert_equal(["Yavin", "Echo Base", "Secret Hideout"], get_names(result))
+        assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+        fourth_cursor = "NA=="
+        first_second_and_third_names = ["Yavin", "Echo Base", "Secret Hideout"]
+        result = star_wars_query(query_string, "last" => 100, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+
+        result = star_wars_query(query_string, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+      end
+    end
   end
 end

data/spec/graphql/relay/relation_connection_spec.rb

@@ -225,6 +225,65 @@ describe GraphQL::Relay::RelationConnection do
         assert_equal(first_and_second_names, get_names(result))
       end
     end
+
+    describe "applying default_max_page_size" do
+      let(:query_string) {%|
+        query getBases($first: Int, $after: String, $last: Int, $before: String){
+          empire {
+            bases: basesWithDefaultMaxLimitRelation(first: $first, after: $after, last: $last, before: $before) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BaseConnection {
+          edges {
+            cursor
+            node {
+              name
+            }
+          },
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+        |}
+
+      it "applies to queries by `first`" do
+        result = star_wars_query(query_string, "first" => 100)
+        assert_equal(3, result["data"]["empire"]["bases"]["edges"].size)
+        assert_equal(true, result["data"]["empire"]["bases"]["pageInfo"]["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = star_wars_query(query_string)
+        assert_equal(3, result["data"]["empire"]["bases"]["edges"].size)
+        assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasNextPage"], "hasNextPage is false when first is not specified")
+      end
+
+      it "applies to queries by `last`" do
+        second_to_last_three_names = ["Secret Hideout", "Death Star", "Shield Generator"]
+        first_second_and_third_names = ["Yavin", "Echo Base", "Secret Hideout"]
+
+        last_cursor = "Ng=="
+        result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
+        assert_equal(second_to_last_three_names, get_names(result))
+        assert_equal(true, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+        result = star_wars_query(query_string, "before" => last_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+        assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+        fourth_cursor = "NA=="
+        result = star_wars_query(query_string, "last" => 100, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+
+        result = star_wars_query(query_string, "before" => fourth_cursor)
+        assert_equal(first_second_and_third_names, get_names(result))
+      end
+    end
   end
 
   describe "without a block" do

data/spec/graphql/schema/rescue_middleware_spec.rb

@@ -2,6 +2,7 @@
 require "spec_helper"
 
 class SpecExampleError < StandardError; end
+class SecondSpecExampleError < StandardError; end
 
 describe GraphQL::Schema::RescueMiddleware do
   let(:error_middleware) { ->{ raise(error_class) } }
@@ -23,6 +24,20 @@ describe GraphQL::Schema::RescueMiddleware do
       assert_equal("there was an example error: SpecExampleError", result.message)
       assert_equal(GraphQL::ExecutionError, result.class)
     end
+
+    describe "with multiple error classes" do
+      let(:error_class) { SecondSpecExampleError }
+      let(:rescue_middleware) do
+        middleware = GraphQL::Schema::RescueMiddleware.new
+        middleware.rescue_from(SpecExampleError, SecondSpecExampleError) { |err| "there was an example error: #{err.class.name}" }
+        middleware
+      end
+
+      it "handles errors for all of the classes" do
+        result = middleware_chain.invoke([])
+        assert_equal("there was an example error: SecondSpecExampleError", result.message)
+      end
+    end
   end
 
   describe "unknown errors" do
@@ -31,4 +46,18 @@ describe GraphQL::Schema::RescueMiddleware do
       assert_raises(RuntimeError) { middleware_chain.invoke([]) }
     end
   end
+
+  describe "removing multiple error handlers" do
+    let(:error_class) { SpecExampleError }
+    let(:rescue_middleware) do
+      middleware = GraphQL::Schema::RescueMiddleware.new
+      middleware.rescue_from(SpecExampleError, SecondSpecExampleError) { |err| "there was an example error: #{err.class.name}" }
+      middleware.remove_handler(SpecExampleError, SecondSpecExampleError)
+      middleware
+    end
+
+    it "no longer handles those errors" do
+      assert_raises(SpecExampleError) { middleware_chain.invoke([]) }
+    end
+  end
 end

data/spec/graphql/schema_spec.rb

@@ -360,4 +360,13 @@ type Query {
       assert_equal result, JSON.parse(schema.to_json)
     end
   end
+
+  describe "#get_field" do
+    it "returns fields by type or type name" do
+      field = schema.get_field("Cheese", "id")
+      assert_instance_of GraphQL::Field, field
+      field_2 = schema.get_field(Dummy::CheeseType, "id")
+      assert_equal field, field_2
+    end
+  end
 end

data/spec/support/star_wars/schema.rb

@@ -96,7 +96,7 @@ module StarWars
 
     field :id, !types.ID, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
     field :name, types.String
-    connection :ships, ShipConnectionWithParentType do
+    connection :ships, ShipConnectionWithParentType, max_page_size: 1000 do
       resolve ->(obj, args, ctx) {
         all_ships = obj.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
         if args[:nameIncludes]
@@ -159,7 +159,15 @@ module StarWars
       resolve ->(object, args, context) { Base.all.to_a }
     end
 
-    connection :basesAsSequelDataset, BaseConnectionWithTotalCountType do
+    connection :basesWithDefaultMaxLimitRelation, BaseType.connection_type do
+      resolve ->(object, args, context) { Base.all }
+    end
+
+    connection :basesWithDefaultMaxLimitArray, BaseType.connection_type do
+      resolve ->(object, args, context) { Base.all.to_a }
+    end
+
+    connection :basesAsSequelDataset, BaseConnectionWithTotalCountType, max_page_size: 1000 do
       argument :nameIncludes, types.String
       resolve ->(obj, args, ctx) {
         all_bases = SequelBase.where(faction_id: obj.id)
@@ -332,6 +340,7 @@ module StarWars
   Schema = GraphQL::Schema.define do
     query(QueryType)
     mutation(MutationType)
+    default_max_page_size 3
 
     resolve_type ->(object, ctx) {
       if object == :test_error

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-28 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips