graphql 1.5.15 → 1.6.0

data/lib/graphql/schema/build_from_definition.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "graphql/schema/build_from_definition/resolve_map"
+
 module GraphQL
   class Schema
     module BuildFromDefinition
@@ -23,24 +25,6 @@ module GraphQL
         end
       end
 
-      # @api private
-      class ResolveMap
-        def initialize(resolve_hash)
-          @resolve_hash = resolve_hash
-        end
-
-        def call(type, field, obj, args, ctx)
-          type_hash = @resolve_hash[type.name]
-          type_hash && (resolver = type_hash[field.name])
-
-          if resolver.nil?
-            raise(KeyError, "resolver not found for #{type.name}.#{field.name}")
-          else
-            resolver.call(obj, args, ctx)
-          end
-        end
-      end
-
       # @api private
       module Builder
         extend self
@@ -72,7 +56,7 @@ module GraphQL
             when GraphQL::Language::Nodes::UnionTypeDefinition
               types[definition.name] = build_union_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ScalarTypeDefinition
-              types[definition.name] = build_scalar_type(definition, type_resolver)
+              types[definition.name] = build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
             when GraphQL::Language::Nodes::InputObjectTypeDefinition
               types[definition.name] = build_input_object_type(definition, type_resolver)
             when GraphQL::Language::Nodes::DirectiveDefinition
@@ -107,17 +91,23 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
-          Schema.define do
+          schema = Schema.define do
             raise_definition_error true
 
             query query_root_type
             mutation mutation_root_type
             subscription subscription_root_type
             orphan_types types.values
-            resolve_type NullResolveType
+            if default_resolve.respond_to?(:resolve_type)
+              resolve_type(default_resolve.method(:resolve_type))
+            else
+              resolve_type(NullResolveType)
+            end
 
             directives directives.values
           end
+
+          schema
         end
 
         NullResolveType = ->(obj, ctx) {
@@ -151,12 +141,21 @@ module GraphQL
           reason.value
         end
 
-        def build_scalar_type(scalar_type_definition, type_resolver)
-          GraphQL::ScalarType.define(
+        def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+          scalar_type = GraphQL::ScalarType.define(
             name: scalar_type_definition.name,
             description: scalar_type_definition.description,
             coerce: NullScalarCoerce,
           )
+
+          if default_resolve.respond_to?(:coerce_input)
+            scalar_type = scalar_type.redefine(
+              coerce_input: ->(val, ctx) { default_resolve.coerce_input(scalar_type, val, ctx) },
+              coerce_result: ->(val, ctx) { default_resolve.coerce_result(scalar_type, val, ctx) },
+            )
+          end
+
+          scalar_type
         end
 
         def build_union_type(union_type_definition, type_resolver)

data/lib/graphql/schema/build_from_definition/resolve_map.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "graphql/schema/build_from_definition/resolve_map/default_resolve"
+
+module GraphQL
+  class Schema
+    module BuildFromDefinition
+      # Wrap a user-provided hash of resolution behavior for easy access at runtime.
+      #
+      # Coerce scalar values by:
+      # - Checking for a function in the map like `{ Date: { coerce_input: ->(val, ctx) { ... }, coerce_result: ->(val, ctx) { ... } } }`
+      # - Falling back to a passthrough
+      #
+      # Interface/union resolution can be provided as a `resolve_type:` key.
+      #
+      # @api private
+      class ResolveMap
+        def initialize(user_resolve_hash)
+          @resolve_hash = Hash.new do |h, k|
+            # For each type name, provide a new hash if one wasn't given:
+            h[k] = Hash.new do |h2, k2|
+              if k2 == "coerce_input" || k2 == "coerce_result"
+                # This isn't an object field, it's a scalar coerce function.
+                # Use a passthrough
+                Builder::NullScalarCoerce
+              else
+                # For each field, provide a resolver that will
+                # make runtime checks & replace itself
+                h2[k2] = DefaultResolve.new(h2, k2)
+              end
+            end
+          end
+          @user_resolve_hash = user_resolve_hash
+          # User-provided resolve functions take priority over the default:
+          @user_resolve_hash.each do |type_name, fields|
+            type_name_s = type_name.to_s
+            case fields
+            when Hash
+              fields.each do |field_name, resolve_fn|
+                @resolve_hash[type_name_s][field_name.to_s] = resolve_fn
+              end
+            when Proc
+              # for example, __resolve_type
+              @resolve_hash[type_name_s] = fields
+            end
+          end
+
+          # Check the normalized hash, not the user input:
+          if @resolve_hash.key?("resolve_type")
+            define_singleton_method :resolve_type do |type, ctx|
+              @resolve_hash.fetch("resolve_type").call(type, ctx)
+            end
+          end
+        end
+
+        def call(type, field, obj, args, ctx)
+          resolver = @resolve_hash[type.name][field.name]
+          resolver.call(obj, args, ctx)
+        end
+
+        def coerce_input(type, value, ctx)
+          @resolve_hash[type.name]["coerce_input"].call(value, ctx)
+        end
+
+        def coerce_result(type, value, ctx)
+          @resolve_hash[type.name]["coerce_result"].call(value, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/build_from_definition/resolve_map/default_resolve.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module BuildFromDefinition
+      class ResolveMap
+        class DefaultResolve
+          def initialize(field_map, field_name)
+            @field_map = field_map
+            @field_name = field_name
+          end
+
+          # Make some runtime checks about
+          # how `obj` implements the `field_name`.
+          #
+          # Create a new resolve function according to that implementation, then:
+          #   - update `field_map` with this implementation
+          #   - call the implementation now (to satisfy this field execution)
+          #
+          # If `obj` doesn't implement `field_name`, raise an error.
+          def call(obj, args, ctx)
+            method_name = @field_name
+            if !obj.respond_to?(method_name)
+              raise KeyError, "Can't resolve field #{method_name} on #{obj}"
+            else
+              method_arity = obj.method(method_name).arity
+              resolver = case method_arity
+              when 0, -1
+                # -1 Handles method_missing, eg openstruct
+                ->(o, a, c) { o.public_send(method_name) }
+              when 1
+                ->(o, a, c) { o.public_send(method_name, a) }
+              when 2
+                ->(o, a, c) { o.public_send(method_name, a, c) }
+              else
+                raise "Unexpected resolve arity: #{method_arity}. Must be 0, 1, 2"
+              end
+              # Call the resolver directly next time
+              @field_map[method_name] = resolver
+              # Call through this time
+              resolver.call(obj, args, ctx)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/middleware_chain.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
     class MiddlewareChain
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
       attr_reader :steps, :final_step

data/lib/graphql/schema/printer.rb

@@ -49,7 +49,8 @@ module GraphQL
         @context = context
 
         blacklist = build_blacklist(only, except, introspection: introspection)
-        @warden = GraphQL::Schema::Warden.new(blacklist, schema: @schema, context: @context)
+        filter = GraphQL::Filter.new(except: blacklist)
+        @warden = GraphQL::Schema::Warden.new(filter, schema: @schema, context: @context)
       end
 
       # Return the GraphQL schema string for the introspection type system

data/lib/graphql/schema/timeout_middleware.rb

@@ -24,18 +24,18 @@ module GraphQL
     #   end
     #
     class TimeoutMiddleware
-      # This key is used for storing timeout data in the {Query::Context} instance
-      DEFAULT_CONTEXT_KEY = :__timeout_at__
       # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
-      # @param context_key [Symbol] what key should be used to read and write to the query context
-      def initialize(max_seconds:, context_key: DEFAULT_CONTEXT_KEY, &block)
+      def initialize(max_seconds:, context_key: nil, &block)
         @max_seconds = max_seconds
-        @context_key = context_key
+        if context_key
+          warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
+        end
         @error_handler = block
       end
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
-        timeout_at = query_context[@context_key] ||= Time.now + @max_seconds
+        ns = query_context.namespace(TimeoutMiddleware)
+        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
 
         if timeout_at < Time.now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)

data/lib/graphql/schema/type_map.rb

@@ -8,7 +8,7 @@ module GraphQL
     #
     # If you want a type, but want to handle the undefined case, use {#fetch}.
     class TypeMap
-      extend GraphQL::Delegate
+      extend Forwardable
       def_delegators :@storage, :key?, :keys, :values, :to_h, :fetch, :each, :each_value
 
       def initialize

data/lib/graphql/schema/warden.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
-    # Restrict access to a {GraphQL::Schema} with a user-defined mask.
-    #
-    # The mask is object that responds to `#visible?(schema_member)`.
+    # Restrict access to a {GraphQL::Schema} with a user-defined filter.
     #
     # When validating and executing a query, all access to schema members
     # should go through a warden. If you access the schema directly,
     # you may show a client something that it shouldn't be allowed to see.
     #
-    # Masks can be provided in {Schema#execute} (or {Query#initialize}) with the `mask:` keyword.
-    #
     # @example Hidding private fields
     #   private_members = -> (member, ctx) { member.metadata[:private] }
     #   result = Schema.execute(query_string, except: private_members)
     #
-    # @example Custom mask implementation
+    # @example Custom filter implementation
     #   # It must respond to `#call(member)`.
     #   class MissingRequiredFlags
     #     def initialize(user)
@@ -38,13 +34,13 @@ module GraphQL
     #
     # @api private
     class Warden
-      # @param mask [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
+      # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
       # @param deep_check [Boolean]
-      def initialize(mask, context:, schema:)
+      def initialize(filter, context:, schema:)
         @schema = schema
-        @visibility_cache = read_through { |m| !mask.call(m, context) }
+        @visibility_cache = read_through { |m| filter.call(m, context) }
       end
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -103,7 +103,7 @@ module GraphQL
       end
 
       class NodeWithPath
-        extend GraphQL::Delegate
+        extend Forwardable
         attr_reader :node, :path
         def initialize(node, path)
           @node = node

data/lib/graphql/version.rb

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

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -9,7 +9,7 @@ describe GraphQL::Analysis do
 
     def call(memo, visit_type, irep_node)
       if visit_type == :enter
-        memo + [irep_node.return_type]
+        memo + [irep_node.return_type.unwrap]
       else
         memo
       end
@@ -83,7 +83,7 @@ describe GraphQL::Analysis do
           memo ||= Hash.new { |h,k| h[k] = 0 }
           if visit_type == :enter
             if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-              if irep_node.definition.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve)
+              if irep_node.definition.connection?
                 memo[:connection] ||= 0
                 memo[:connection] += 1
               else

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -60,4 +60,32 @@ describe GraphQL::Analysis::MaxQueryComplexity do
       assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result["errors"][0]["message"]
     end
   end
+
+  describe "across a multiplex" do
+    before do
+      Dummy::Schema.max_complexity = 9
+    end
+
+    let(:queries) { 5.times.map { |n|  { query: "{ cheese(id: #{n}) { id } }" } } }
+
+    it "returns errors for all queries" do
+      results = Dummy::Schema.multiplex(queries)
+      assert_equal 5, results.length
+      err_msg = "Query has complexity of 10, which exceeds max complexity of 9"
+      results.each do |res|
+        assert_equal err_msg, res["errors"][0]["message"]
+      end
+    end
+
+    describe "with a local override" do
+      it "uses the override" do
+        results = Dummy::Schema.multiplex(queries, max_complexity: 10)
+        assert_equal 5, results.length
+        results.each do |res|
+          assert_equal true, res.key?("data")
+          assert_equal false, res.key?("errors")
+        end
+      end
+    end
+  end
 end

data/spec/graphql/argument_spec.rb

@@ -60,14 +60,14 @@ describe GraphQL::Argument do
 
   describe "prepare" do
     it "accepts a prepare proc and calls it to generate the prepared value" do
-      prepare_proc = Proc.new { |arg| arg + 1 }
+      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
       argument = GraphQL::Argument.define(name: :plusOne, type: GraphQL::INT_TYPE, prepare: prepare_proc)
-      assert_equal argument.prepare(1), 2
+      assert_equal argument.prepare(1, {val: 1}), 2
     end
 
     it "returns the value itself if no prepare proc is provided" do
       argument = GraphQL::Argument.define(name: :someNumber, type: GraphQL::INT_TYPE)
-      assert_equal argument.prepare(1), 1
+      assert_equal argument.prepare(1, nil), 1
     end
   end
 end

data/spec/graphql/execution/lazy_spec.rb

@@ -2,117 +2,11 @@
 require "spec_helper"
 
 describe GraphQL::Execution::Lazy do
-  class Wrapper
-    def initialize(item = nil, &block)
-      if block
-        @block = block
-      else
-        @item = item
-      end
-    end
-
-    def item
-      if @block
-        @item = @block.call()
-        @block = nil
-      end
-      @item
-    end
-  end
-
-  class SumAll
-    attr_reader :own_value
-    attr_accessor :value
-
-    def initialize(ctx, own_value)
-      @own_value = own_value
-      @all = ctx[:__sum_all__] ||= []
-      @all << self
-    end
-
-    def value
-      @value ||= begin
-        total_value = @all.map(&:own_value).reduce(&:+)
-        @all.each { |v| v.value = total_value}
-        @all.clear
-        total_value
-      end
-      @value
-    end
-  end
-
-  LazySum = GraphQL::ObjectType.define do
-    name "LazySum"
-    field :value, types.Int do
-      resolve ->(o, a, c) { o == 13 ? nil : o }
-    end
-    field :nestedSum, !LazySum do
-      argument :value, !types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new(nil)
-        else
-          SumAll.new(c, o + args[:value])
-        end
-      }
-    end
-
-    field :nullableNestedSum, LazySum do
-      argument :value, types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new(nil)
-        else
-          SumAll.new(c, o + args[:value])
-        end
-      }
-    end
-  end
-
-  LazyQuery = GraphQL::ObjectType.define do
-    name "Query"
-    field :int, !types.Int do
-      argument :value, !types.Int
-      argument :plus, types.Int, default_value: 0
-      resolve ->(o, a, c) { Wrapper.new(a[:value] + a[:plus])}
-    end
-
-    field :nestedSum, !LazySum do
-      argument :value, !types.Int
-      resolve ->(o, args, c) { SumAll.new(c, args[:value]) }
-    end
-
-    field :nullableNestedSum, LazySum do
-      argument :value, types.Int
-      resolve ->(o, args, c) {
-        if args[:value] == 13
-          Wrapper.new { raise GraphQL::ExecutionError.new("13 is unlucky") }
-        else
-          SumAll.new(c, args[:value])
-        end
-      }
-    end
-
-    field :listSum, types[LazySum] do
-      argument :values, types[types.Int]
-      resolve ->(o, args, c) { args[:values] }
-    end
-  end
-
-  LazySchema = GraphQL::Schema.define do
-    query(LazyQuery)
-    mutation(LazyQuery)
-    lazy_resolve(Wrapper, :item)
-    lazy_resolve(SumAll, :value)
-  end
-
-  def run_query(query_str)
-    LazySchema.execute(query_str)
-  end
+  include LazyHelpers
 
   describe "resolving" do
     it "calls value handlers" do
-      res = run_query('{  int(value: 2, plus: 1)}')
+      res = run_query('{  int(value: 2, plus: 1) }')
       assert_equal 3, res["data"]["int"]
     end
 
@@ -234,16 +128,16 @@ describe GraphQL::Execution::Lazy do
   end
 
   describe "LazyMethodMap" do
-    class SubWrapper < Wrapper; end
+    class SubWrapper < LazyHelpers::Wrapper; end
 
     let(:map) { GraphQL::Execution::Lazy::LazyMethodMap.new }
 
     it "finds methods for classes and subclasses" do
-      map.set(Wrapper, :item)
-      map.set(SumAll, :value)
-      b = Wrapper.new(1)
-      sub_b = Wrapper.new(2)
-      s = SumAll.new({}, 3)
+      map.set(LazyHelpers::Wrapper, :item)
+      map.set(LazyHelpers::SumAll, :value)
+      b = LazyHelpers::Wrapper.new(1)
+      sub_b = LazyHelpers::Wrapper.new(2)
+      s = LazyHelpers::SumAll.new({}, 3)
       assert_equal(:item, map.get(b))
       assert_equal(:item, map.get(sub_b))
       assert_equal(:value, map.get(s))