graphql 1.8.8 → 1.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8642c253947a56246003a995f373e3088b70848
-  data.tar.gz: 0e027e906d12ff726e144220849ac216b66dc56d
+  metadata.gz: 4378912bdbb59ceaa6006848e6eda269f1185df1
+  data.tar.gz: 5dd1788b97f608a67ffa5c27f6848a575f996daa
 SHA512:
-  metadata.gz: cfabff78ee8e8bb710ee73bfcb191d7b040a55eb042a2b94cf8d8d3169671b954aa13901c095124a516d593f49d21f1c9f2f63ed2731308e77e74fbffad9d726
-  data.tar.gz: d924393eea98ab77207c0fa35abc579373f650000e66b82cd181f1e5286b58d8794e29fcc4f3796f3b8db6f0dec0c7293e8244275cdceb0f45f39bde556f8f89
+  metadata.gz: 3f9e4c341f98a13ad1018c0ae9b5c1f1063f5c5cbf8485b29c164f485f79257b8dc148db9fb959fdad9e8aa9f3d4eb05648a27b9a2168387ca3649b994f200ab
+  data.tar.gz: e5cbe104fb2f6d06f4fdf0cf51f931367845f933440e8143897207af1bfb7302c6ae7fca0d823cc3b593bb5f83545c3c030a00c6c5a9d008b9f545a1666a52dd

data/lib/graphql/base_type.rb

@@ -187,7 +187,7 @@ module GraphQL
         resolve_related_type(type_arg.call)
       when String
         # Get a constant by this name
-        Object.const_get(type_arg)
+        resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
           type_arg.graphql_definition

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -49,8 +49,7 @@ module GraphQL
         end
 
         module TestMiddleware
-          # TODO: Once deprecated `next_middleware` argument becomes unsupported, add `&` to the argument
-          def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+          def self.call(parent_type, parent_object, field_definition, field_args, query_context, &next_middleware)
             query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
             next_middleware.call
           end

data/lib/graphql/enum_type.rb

@@ -169,6 +169,10 @@ module GraphQL
     def coerce_non_null_input(value_name, ctx)
       if @values_by_name.key?(value_name)
         @values_by_name.fetch(value_name).value
+      elsif match_by_value = @values_by_name.find { |k, v| v.value == value_name }
+        # this is for matching default values, which are "inputs", but they're
+        # the Ruby value, not the GraphQL string.
+        match_by_value[1].value
       else
         nil
       end

data/lib/graphql/execution/execute.rb

@@ -142,11 +142,11 @@ module GraphQL
         # If the returned object is finished, continue to coerce
         # and resolve child fields
         def continue_or_wait(raw_value, field_type, field_ctx)
-          if (lazy_method = field_ctx.schema.lazy_method_name(raw_value))
+          if field_ctx.schema.lazy?(raw_value)
             field_ctx.value = Execution::Lazy.new {
               inner_value = begin
                   begin
-                    raw_value.public_send(lazy_method)
+                    field_ctx.schema.sync_lazy(raw_value)
                   rescue GraphQL::UnauthorizedError => err
                     field_ctx.schema.unauthorized_object(err)
                   end

data/lib/graphql/field.rb

@@ -323,13 +323,7 @@ module GraphQL
 
     module DefaultLazyResolve
       def self.call(obj, args, ctx)
-        method_name = ctx.schema.lazy_method_name(obj)
-        next_obj = obj.public_send(method_name)
-        if ctx.schema.lazy?(next_obj)
-          call(next_obj, args, ctx)
-        else
-          next_obj
-        end
+        ctx.schema.sync_lazy(obj)
       end
     end
   end

data/lib/graphql/schema.rb

@@ -657,7 +657,7 @@ module GraphQL
         :static_validator, :introspection_system,
         :query_analyzers, :tracers, :instrumenters,
         :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-        :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy,
+        :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy, :sync_lazy,
         # Configuration
         :max_complexity=, :max_depth=,
         :metadata,
@@ -1001,9 +1001,9 @@ module GraphQL
     # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
     # @api private
     def after_lazy(value)
-      if (lazy_method = lazy_method_name(value))
+      if lazy?(value)
         GraphQL::Execution::Lazy.new do
-          result = value.public_send(lazy_method)
+          result = sync_lazy(value)
           # The returned result might also be lazy, so check it, too
           after_lazy(result) do |final_result|
             yield(final_result) if block_given?
@@ -1014,6 +1014,28 @@ module GraphQL
       end
     end
 
+    # Override this method to handle lazy objects in a custom way.
+    # @param value [Object] an instance of a class registered with {.lazy_resolve}
+    # @param ctx [GraphQL::Query::Context] the context for this query
+    # @return [Object] A GraphQL-ready (non-lazy) object
+    def self.sync_lazy(value)
+      yield(value)
+    end
+
+    # @see Schema.sync_lazy for a hook to override
+    # @api private
+    def sync_lazy(value)
+      self.class.sync_lazy(value) { |v|
+        lazy_method = lazy_method_name(v)
+        if lazy_method
+          synced_value = value.public_send(lazy_method)
+          sync_lazy(synced_value)
+        else
+          v
+        end
+      }
+    end
+
     protected
 
     def rescues?

data/lib/graphql/schema/argument.rb

@@ -97,12 +97,11 @@ module GraphQL
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value)
-        case @prepare
-        when nil
+        if @prepare.nil?
           value
-        when Symbol, String
+        elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
           obj.public_send(@prepare, value)
-        when Proc
+        elsif @prepare.respond_to?(:call)
           @prepare.call(value, obj.context)
         else
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"

data/lib/graphql/schema/field.rb

@@ -126,7 +126,7 @@ module GraphQL
       # @param complexity [Numeric] When provided, set the complexity for this field
       # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, trace: nil, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
 
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
@@ -170,6 +170,7 @@ module GraphQL
         @extras = extras
         @resolver_class = resolver_class
         @scope = scope
+        @trace = trace
 
         # Override the default from HasArguments
         @own_arguments = {}
@@ -186,7 +187,7 @@ module GraphQL
 
         if definition_block
           if definition_block.arity == 1
-            instance_exec(self, &definition_block)
+            yield self
           else
             instance_eval(&definition_block)
           end
@@ -258,6 +259,10 @@ module GraphQL
           field_defn.metadata[:resolver] = @resolver_class
         end
 
+        if !@trace.nil?
+          field_defn.trace = @trace
+        end
+
         field_defn.resolve = self.method(:resolve_field)
         field_defn.connection = connection?
         field_defn.connection_max_page_size = @max_page_size
@@ -401,6 +406,17 @@ module GraphQL
         end
       end
 
+      # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
+      def fetch_extra(extra_name, ctx)
+        if respond_to?(extra_name)
+          self.public_send(extra_name)
+        elsif ctx.respond_to?(extra_name)
+          ctx.public_send(extra_name)
+        else
+          raise NotImplementedError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
+        end
+      end
+
       NO_ARGS = {}.freeze
 
       def public_send_field(obj, graphql_args, field_ctx)
@@ -424,8 +440,7 @@ module GraphQL
           end
 
           @extras.each do |extra_arg|
-            # TODO: provide proper tests for `:ast_node`, `:irep_node`, `:parent`, others?
-            ruby_kwargs[extra_arg] = field_ctx.public_send(extra_arg)
+            ruby_kwargs[extra_arg] = fetch_extra(extra_arg, field_ctx)
           end
         else
           ruby_kwargs = NO_ARGS

data/lib/graphql/types/iso_8601_date_time.rb

@@ -15,10 +15,24 @@ module GraphQL
     class ISO8601DateTime < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded datetime"
 
+      # It's not compatible with Rails' default,
+      # i.e. ActiveSupport::JSON::Encoder.time_precision (3 by default)
+      DEFAULT_TIME_PRECISION = 0
+
+      # @return [Integer]
+      def self.time_precision
+        @time_precision || DEFAULT_TIME_PRECISION
+      end
+
+      # @param [Integer] value
+      def self.time_precision=(value)
+        @time_precision = value
+      end
+
       # @param value [DateTime]
       # @return [String]
       def self.coerce_result(value, _ctx)
-        value.iso8601
+        value.iso8601(time_precision)
       end
 
       # @param str_value [String]

data/lib/graphql/version.rb

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

data/readme.md

@@ -37,7 +37,7 @@ Or, see ["Getting Started"](https://rmosolgo.github.io/graphql-ruby/).
 
 ## Upgrade
 
-I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [Pusher-based subscriptions](http://graphql-ruby.org/subscriptions/pusher_implementation) and [persisted queries](http://rmosolgo.github.io/graphql-ruby/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
+I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [Pundit authorization](http://rmosolgo.github.io/graphql-ruby/authorization/pundit_integration), [CanCan authorization](http://rmosolgo.github.io/graphql-ruby/authorization/can_can_integration), [Pusher-based subscriptions](http://graphql-ruby.org/subscriptions/pusher_implementation) and [persisted queries](http://rmosolgo.github.io/graphql-ruby/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
 
 ## Goals
 

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -78,7 +78,7 @@ describe GraphQL::Analysis do
 
     it "calls the defined analyzers" do
       collected_types, node_counts = reduce_result
-      expected_visited_types = [Dummy::DairyAppQueryType, Dummy::CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
+      expected_visited_types = [Dummy::DairyAppQuery.graphql_definition, Dummy::Cheese.graphql_definition, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
       assert_equal expected_visited_types, collected_types
       expected_node_counts = {
         GraphQL::Language::Nodes::OperationDefinition => 1,

data/spec/graphql/base_type_spec.rb

@@ -11,7 +11,7 @@ describe GraphQL::BaseType do
   end
 
   it "can be compared" do
-    obj_type = Dummy::MilkType
+    obj_type = Dummy::Milk.graphql_definition
     assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
     refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
     assert_equal(
@@ -25,7 +25,7 @@ describe GraphQL::BaseType do
   end
 
   it "Accepts arbitrary metadata" do
-    assert_equal ["Cheese"], Dummy::CheeseType.metadata[:class_names]
+    assert_equal ["Cheese"], Dummy::Cheese.graphql_definition.metadata[:class_names]
   end
 
   describe "#name" do
@@ -63,7 +63,7 @@ describe GraphQL::BaseType do
   end
 
   describe "forwards-compat with new api" do
-    let(:type_defn) { Dummy::CheeseType }
+    let(:type_defn) { Dummy::Cheese.graphql_definition }
     it "responds to new methods" do
       assert_equal "Cheese", type_defn.graphql_name
       assert_equal type_defn, type_defn.graphql_definition

data/spec/graphql/enum_type_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe GraphQL::EnumType do
-  let(:enum) { Dummy::DairyAnimalEnum }
+  let(:enum) { Dummy::DairyAnimal.graphql_definition }
 
   it "coerces names to underlying values" do
     assert_equal("YAK", enum.coerce_isolated_input("YAK"))

data/spec/graphql/execution/lazy_spec.rb

@@ -155,6 +155,23 @@ describe GraphQL::Execution::Lazy do
     end
   end
 
+  describe "Schema#sync_lazy(object)" do
+    it "Passes objects to that hook at runtime" do
+      res = run_query <<-GRAPHQL
+      {
+        a: nullableNestedSum(value: 1001) { value }
+        b: nullableNestedSum(value: 1013) { value }
+        c: nullableNestedSum(value: 1002) { value }
+      }
+      GRAPHQL
+
+      # This odd, non-adding behavior is hacked into `#sync_lazy`
+      assert_equal 101, res["data"]["a"]["value"]
+      assert_equal 113, res["data"]["b"]["value"]
+      assert_equal 102, res["data"]["c"]["value"]
+    end
+  end
+
   describe "LazyMethodMap" do
     class SubWrapper < LazyHelpers::Wrapper; end
 
@@ -165,7 +182,7 @@ describe GraphQL::Execution::Lazy do
       map.set(LazyHelpers::SumAll, :value)
       b = LazyHelpers::Wrapper.new(1)
       sub_b = LazyHelpers::Wrapper.new(2)
-      s = LazyHelpers::SumAll.new({}, 3)
+      s = LazyHelpers::SumAll.new(3)
       assert_equal(:item, map.get(b))
       assert_equal(:item, map.get(sub_b))
       assert_equal(:value, map.get(s))

data/spec/graphql/execution/typecast_spec.rb

@@ -8,36 +8,36 @@ describe GraphQL::Execution::Typecast do
     end
 
     it "counts the same type as a subtype" do
-      assert subtype?(Dummy::MilkType, Dummy::MilkType)
-      assert !subtype?(Dummy::MilkType, Dummy::CheeseType)
-      assert subtype?(Dummy::MilkType.to_list_type.to_non_null_type, Dummy::MilkType.to_list_type.to_non_null_type)
+      assert subtype?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition)
+      assert !subtype?(Dummy::Milk.graphql_definition, Dummy::Cheese.graphql_definition)
+      assert subtype?(Dummy::Milk.graphql_definition.to_list_type.to_non_null_type, Dummy::Milk.graphql_definition.to_list_type.to_non_null_type)
     end
 
     it "counts member types as subtypes" do
-      assert subtype?(Dummy::EdibleInterface, Dummy::CheeseType)
-      assert subtype?(Dummy::EdibleInterface, Dummy::MilkType)
-      assert subtype?(Dummy::DairyProductUnion, Dummy::MilkType)
-      assert subtype?(Dummy::DairyProductUnion, Dummy::CheeseType)
+      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Cheese.graphql_definition)
+      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition)
+      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Milk.graphql_definition)
+      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Cheese.graphql_definition)
 
-      assert !subtype?(Dummy::DairyAppQueryType, Dummy::DairyProductUnion)
-      assert !subtype?(Dummy::CheeseType, Dummy::DairyProductUnion)
-      assert !subtype?(Dummy::EdibleInterface, Dummy::DairyProductUnion)
-      assert !subtype?(Dummy::EdibleInterface, GraphQL::STRING_TYPE)
-      assert !subtype?(Dummy::EdibleInterface, Dummy::DairyProductInputType)
+      assert !subtype?(Dummy::DairyAppQuery.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Cheese.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProduct.graphql_definition)
+      assert !subtype?(Dummy::Edible.graphql_definition, GraphQL::STRING_TYPE)
+      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProductInput.graphql_definition)
     end
 
     it "counts lists as subtypes if their inner types are subtypes" do
-      assert subtype?(Dummy::EdibleInterface.to_list_type, Dummy::MilkType.to_list_type)
-      assert subtype?(Dummy::DairyProductUnion.to_list_type, Dummy::MilkType.to_list_type)
-      assert !subtype?(Dummy::CheeseType.to_list_type, Dummy::DairyProductUnion.to_list_type)
-      assert !subtype?(Dummy::EdibleInterface.to_list_type, Dummy::DairyProductUnion.to_list_type)
-      assert !subtype?(Dummy::EdibleInterface.to_list_type, GraphQL::STRING_TYPE.to_list_type)
+      assert subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
+      assert subtype?(Dummy::DairyProduct.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Cheese.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
+      assert !subtype?(Dummy::Edible.graphql_definition.to_list_type, GraphQL::STRING_TYPE.to_list_type)
     end
 
     it "counts non-null types as subtypes of nullable parent types" do
-      assert subtype?(Dummy::MilkType, Dummy::MilkType.to_non_null_type)
-      assert subtype?(Dummy::EdibleInterface, Dummy::MilkType.to_non_null_type)
-      assert subtype?(Dummy::EdibleInterface.to_non_null_type, Dummy::MilkType.to_non_null_type)
+      assert subtype?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
+      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
+      assert subtype?(Dummy::Edible.graphql_definition.to_non_null_type, Dummy::Milk.graphql_definition.to_non_null_type)
       assert subtype?(
         GraphQL::STRING_TYPE.to_non_null_type.to_list_type,
         GraphQL::STRING_TYPE.to_non_null_type.to_list_type.to_non_null_type,

data/spec/graphql/field_spec.rb

@@ -116,7 +116,7 @@ describe GraphQL::Field do
 
   describe "#metadata" do
     it "accepts user-defined metadata" do
-      similar_cheese_field = Dummy::CheeseType.get_field("similarCheese")
+      similar_cheese_field = Dummy::Cheese.graphql_definition.get_field("similarCheese")
       assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
     end
   end

data/spec/graphql/input_object_type_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe GraphQL::InputObjectType do
+  describe 'default values' do
+    describe 'when the type is an enum with underlying ruby values' do
+      it 'provides the default value' do
+        TestEnum = GraphQL::EnumType.define do
+          name 'Test'
+
+          value 'A', 'Represents an authorized agent in our system.', value: 'a'
+          value 'B', 'Agent is disabled, web app access is denied.', value: 'b'
+        end
+
+        class TestInput < GraphQL::Schema::InputObject
+          argument :foo, TestEnum, 'TestEnum', required: false, default_value: 'a'
+        end
+
+        test_input_type = TestInput.to_graphql
+        default_test_input_value = test_input_type.coerce_isolated_input({})
+        assert_equal default_test_input_value[:foo], 'a'
+      end
+    end
+  end
+end

data/spec/graphql/interface_type_spec.rb

@@ -2,11 +2,11 @@
 require "spec_helper"
 
 describe GraphQL::InterfaceType do
-  let(:interface) { Dummy::EdibleInterface }
+  let(:interface) { Dummy::Edible.graphql_definition }
   let(:dummy_query_context) { OpenStruct.new(schema: Dummy::Schema) }
 
   it "has possible types" do
-    assert_equal([Dummy::CheeseType, Dummy::HoneyType, Dummy::MilkType], Dummy::Schema.possible_types(interface))
+    assert_equal([Dummy::Cheese.graphql_definition, Dummy::Honey.graphql_definition, Dummy::Milk.graphql_definition], Dummy::Schema.possible_types(interface))
   end
 
   describe "query evaluation" do
@@ -96,11 +96,11 @@ describe GraphQL::InterfaceType do
     it "copies orphan types without affecting the original" do
       interface = GraphQL::InterfaceType.define do
         name "AInterface"
-        orphan_types [Dummy::HoneyType]
+        orphan_types [Dummy::Honey]
       end
 
       interface_2 = interface.dup
-      interface_2.orphan_types << Dummy::CheeseType
+      interface_2.orphan_types << Dummy::Cheese
       assert_equal 1, interface.orphan_types.size
       assert_equal 2, interface_2.orphan_types.size
     end