graphql 2.0.4 → 2.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 823ea48d61ed1b30e6ad87a6817f80206b9c5d8865f6350cbd142c9798162e37
-  data.tar.gz: 8e5f383cfe80418109b0f424d06ab7a78c72255d167f21f32b6c8f6bcef10610
+  metadata.gz: 8b34cec1ffb7358b467f2fb7c00134db084793d9eb1ebe22f38f351435607c9b
+  data.tar.gz: d15754c440968f51715c0a71f3c23ef1c5fd075793c0de11aae6477976b5aa14
 SHA512:
-  metadata.gz: 95e9de185715e1b2a752ecaefdd75e8b4daad8afd4125429d58627972805d759c3a842a58bec29b0b5ee1aba5e1d06a6cb1aed9bd1881653d710f71fe4edfdc7
-  data.tar.gz: 99ff2f59d77ee74ba4c1af7fcf097afb5415b6d18a95c1a2527413d6f782f8fa6238aafa96430d2d7332f1177e64b70e5aa2eac1557d042ede9eb4a33466b8b5
+  metadata.gz: f2ef024af0f5e1e261fe7b998e27d664df5f92127ffb2874135a6d7b1662763a4e2661634dd46cc67dd624b9fc8291ce1bd3488a460566bc346f9cd6edc86b43
+  data.tar.gz: 635165d9129c2c49510fd481a2161cf425f91ff016bcdb28b8955d1c818d66885a6f7d90c5210e4433ada541d6e116b3137cb12dbdcc44c32229ac564d266b64

data/lib/generators/graphql/install_generator.rb

@@ -47,7 +47,7 @@ module Graphql
     #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
-    # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    # Use `--skip-graphiql` to skip `graphiql-rails` installation.
     #
     # TODO: also add base classes
     class InstallGenerator < Rails::Generators::Base

data/lib/graphql/execution/interpreter/resolve.rb

@@ -59,6 +59,13 @@ module GraphQL
           end
 
           if next_results.any?
+            # Any pending data loader jobs may populate the
+            # resutl arrays or result hashes accumulated in
+            # `next_results``. Run those **to completion**
+            # before continuing to resolve `next_results`.
+            # (Just `.append_job` doesn't work if any pending
+            # jobs require multiple passes.)
+            dataloader.run
             dataloader.append_job { resolve(next_results, dataloader) }
           end
 

data/lib/graphql/execution/lazy.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "graphql/execution/lazy/lazy_method_map"
-require "graphql/execution/lazy/resolve"
 
 module GraphQL
   module Execution

data/lib/graphql/introspection/type_type.rb

@@ -27,7 +27,7 @@ module GraphQL
       end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-      field :specified_by_url, String
+      field :specifiedByURL, String, resolver_method: :specified_by_url
 
       def specified_by_url
         if object.kind.scalar?

data/lib/graphql/introspection.rb

@@ -29,7 +29,7 @@ fragment FullType on __Type {
   kind
   name
   description
-  #{include_specified_by_url ? "specifiedByUrl" : ""}
+  #{include_specified_by_url ? "specifiedByURL" : ""}
   fields(includeDeprecated: true) {
     name
     description

data/lib/graphql/language/printer.rb

@@ -267,12 +267,16 @@ module GraphQL
       end
 
       def print_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_field_definition(field)}\n"
+        if fields.empty?
+          ""
+        else
+          out = " {\n".dup
+          fields.each.with_index do |field, i|
+            out << print_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{print_field_definition(field)}\n"
+          end
+          out << "}"
         end
-        out << "}"
       end
 
       def print_directives(directives)

data/lib/graphql/pagination/array_connection.rb

@@ -35,9 +35,11 @@ module GraphQL
       def load_nodes
         @nodes ||= begin
           sliced_nodes = if before && after
-            items[index_from_cursor(after)..index_from_cursor(before)-1] || []
+            end_idx = index_from_cursor(before)-1
+            end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
           elsif before
-            items[0..index_from_cursor(before)-2] || []
+            end_idx = index_from_cursor(before)-2
+            end_idx < 0 ? [] : items[0..end_idx] || []
           elsif after
             items[index_from_cursor(after)..-1] || []
           else

data/lib/graphql/schema/field.rb

@@ -28,6 +28,9 @@ module GraphQL
       # @return [String] Method or hash key on the underlying object to look up
       attr_reader :method_str
 
+      attr_reader :hash_key
+      attr_reader :dig_keys
+
       # @return [Symbol] The method on the type to look up
       def resolver_method
         if @resolver_class
@@ -243,14 +246,16 @@ module GraphQL
           end
         end
 
-        # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
-        method_name = method || hash_key || name_s
+        method_name = method || name_s
         @dig_keys = dig
-        resolver_method ||= name_s.to_sym
+        if hash_key
+          @hash_key = hash_key
+          @hash_key_str = hash_key.to_s
+        end
 
         @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
-        @resolver_method = resolver_method
+        @resolver_method = (resolver_method || name_s).to_sym
         @complexity = complexity
         @return_type_expr = type
         @return_type_null = if !null.nil?
@@ -635,14 +640,15 @@ module GraphQL
                 obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
               end
 
-              # Find a way to resolve this field, checking:
-              #
-              # - A method on the type instance;
-              # - Hash keys, if the wrapped object is a hash;
-              # - A method on the wrapped object;
-              # - Or, raise not implemented.
-              #
-              if obj.respond_to?(resolver_method)
+              inner_object = obj.object
+
+              if defined?(@hash_key)
+                inner_object.fetch(@hash_key) {
+                  inner_object[@hash_key_str]
+                }
+              elsif @dig_keys
+                inner_object.dig(*@dig_keys)
+              elsif obj.respond_to?(resolver_method)
                 method_to_call = resolver_method
                 method_receiver = obj
                 # Call the method with kwargs, if there are any
@@ -651,30 +657,27 @@ module GraphQL
                 else
                   obj.public_send(resolver_method)
                 end
-              elsif obj.object.is_a?(Hash)
-                inner_object = obj.object
-                if @dig_keys
-                  inner_object.dig(*@dig_keys)
-                elsif inner_object.key?(@method_sym)
+              elsif inner_object.is_a?(Hash)
+                if inner_object.key?(@method_sym)
                   inner_object[@method_sym]
                 else
                   inner_object[@method_str]
                 end
-              elsif obj.object.respond_to?(@method_sym)
+              elsif inner_object.respond_to?(@method_sym)
                 method_to_call = @method_sym
                 method_receiver = obj.object
                 if ruby_kwargs.any?
-                  obj.object.public_send(@method_sym, **ruby_kwargs)
+                  inner_object.public_send(@method_sym, **ruby_kwargs)
                 else
-                  obj.object.public_send(@method_sym)
+                  inner_object.public_send(@method_sym)
                 end
               else
                 raise <<-ERR
               Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
               - `#{obj.class}##{resolver_method}`, which did not exist
-              - `#{obj.object.class}##{@method_sym}`, which did not exist
-              - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+              - `#{inner_object.class}##{@method_sym}`, which did not exist
+              - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{inner_object}`, but it wasn't a Hash
 
               To implement this field, define one of the methods above (and check for typos)
               ERR

data/lib/graphql/schema/loader.rb

@@ -142,7 +142,7 @@ module GraphQL
               Class.new(GraphQL::Schema::Scalar) do
                 graphql_name(type["name"])
                 description(type["description"])
-                specified_by_url(type["specifiedByUrl"])
+                specified_by_url(type["specifiedByURL"])
               end
             end
           when "UNION"

data/lib/graphql/schema/member/has_arguments.rb

@@ -148,7 +148,19 @@ module GraphQL
             end
           elsif defined?(@resolver_class) && @resolver_class
             all_defns = {}
-            all_defns.merge!(@resolver_class.own_field_arguments)
+            @resolver_class.all_field_argument_definitions.each do |arg_defn|
+              key = arg_defn.graphql_name
+              case (current_value = all_defns[key])
+              when nil
+                all_defns[key] = arg_defn
+              when Array
+                current_value << arg_defn
+              when GraphQL::Schema::Argument
+                all_defns[key] = [current_value, arg_defn]
+              else
+                raise "Invariant: Unexpected argument definition, #{current_value.class}: #{current_value.inspect}"
+              end
+            end
             all_defns.merge!(own_arguments)
           else
             all_defns = own_arguments

data/lib/graphql/schema/member/has_fields.rb

@@ -72,7 +72,7 @@ module GraphQL
         def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
           # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
           # that shows that no override value was given manually.
-          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym && field_defn.hash_key.nil? && field_defn.dig_keys.nil?
             warn(conflict_field_name_warning(field_defn))
           end
           prev_defn = own_fields[field_defn.name]

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -92,6 +92,10 @@ module GraphQL
           dummy.own_arguments
         end
 
+        def all_field_argument_definitions
+          dummy.all_argument_definitions
+        end
+
         # Also apply this argument to the input type:
         def argument(*args, own_argument: false, **kwargs, &block)
           it = input_type # make sure any inherited arguments are already added to it

data/lib/graphql/schema/resolver.rb

@@ -73,7 +73,7 @@ module GraphQL
         context.schema.after_lazy(ready_val) do |is_ready, ready_early_return|
           if ready_early_return
             if is_ready != false
-              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{ready_early_return.inspect}]"
+              raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
             else
               ready_early_return
             end
@@ -216,8 +216,8 @@ module GraphQL
           get_argument(name, context)
         end
 
-        def own_field_arguments
-          own_arguments
+        def all_field_argument_definitions
+          all_argument_definitions
         end
 
         # Default `:resolve` set below.

data/lib/graphql/schema/warden.rb

@@ -55,7 +55,9 @@ module GraphQL
               if visible_item.nil?
                 visible_item = item
               else
-                raise Schema::DuplicateNamesError, "Found two visible definitions for `#{item.path}`: #{visible_item.inspect}, #{item.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: item.path, duplicated_definition_1: visible_item.inspect, duplicated_definition_2: item.inspect
+                )
               end
             end
           end
@@ -362,7 +364,9 @@ module GraphQL
           if @reachable_type_set.add?(type)
             type_by_name = rt_hash[type.graphql_name] ||= type
             if type_by_name != type
-              raise DuplicateNamesError, "Found two visible type definitions for `#{type.graphql_name}`: #{type.inspect}, #{type_by_name.inspect}"
+              raise DuplicateNamesError.new(
+                duplicated_name: type.graphql_name, duplicated_definition_1: type.inspect, duplicated_definition_2: type_by_name.inspect
+              )
             end
             if type.kind.input_object?
               # recurse into visible arguments

data/lib/graphql/schema.rb

@@ -73,14 +73,16 @@ module GraphQL
     extend GraphQL::Schema::Member::HasAstNode
     extend GraphQL::Schema::FindInheritedValue
 
-    class DuplicateTypeNamesError < GraphQL::Error
-      def initialize(type_name:, first_definition:, second_definition:, path:)
-        super("Multiple definitions for `#{type_name}`. Previously found #{first_definition.inspect} (#{first_definition.class}), then found #{second_definition.inspect} (#{second_definition.class}) at #{path.join(".")}")
+    class DuplicateNamesError < GraphQL::Error
+      attr_reader :duplicated_name
+      def initialize(duplicated_name:, duplicated_definition_1:, duplicated_definition_2:)
+        @duplicated_name = duplicated_name
+        super(
+          "Found two visible definitions for `#{duplicated_name}`: #{duplicated_definition_1}, #{duplicated_definition_2}"
+        )
       end
     end
 
-    class DuplicateNamesError < GraphQL::Error; end
-
     class UnresolvedLateBoundTypeError < GraphQL::Error
       attr_reader :type
       def initialize(type:)
@@ -225,7 +227,9 @@ module GraphQL
                 if visible_t.nil?
                   visible_t = t
                 else
-                  raise DuplicateNamesError, "Found two visible type definitions for `#{k}`: #{visible_t.inspect}, #{t.inspect}"
+                  raise DuplicateNamesError.new(
+                    duplicated_name: k, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                  )
                 end
               end
             end
@@ -252,7 +256,9 @@ module GraphQL
               if visible_t.nil?
                 visible_t = t
               else
-                raise DuplicateNamesError, "Found two visible type definitions for `#{type_name}`: #{visible_t.inspect}, #{t.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: type_name, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                )
               end
             end
           end
@@ -932,6 +938,7 @@ module GraphQL
           {
             backtrace: ctx[:backtrace],
             tracers: ctx[:tracers],
+            dataloader: ctx[:dataloader],
           }
         else
           {}
@@ -976,7 +983,9 @@ module GraphQL
         if !defined?(@subscription_extension_added) && subscription && self.subscriptions
           @subscription_extension_added = true
           subscription.all_field_definitions.each do |field|
-            field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            if !field.extensions.any? { |ext| ext.is_a?(Subscriptions::DefaultSubscriptionResolveExtension) }
+              field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            end
           end
         end
       end

data/lib/graphql/subscriptions.rb

@@ -39,12 +39,14 @@ module GraphQL
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+    # @param validate_update [Boolean] If false, then validation is skipped when executing updates
+    def initialize(schema:, validate_update: true, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
       end
       @default_broadcastable = default_broadcastable
       @schema = schema
+      @validate_update = validate_update
     end
 
     # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
@@ -117,14 +119,16 @@ module GraphQL
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      result = @schema.execute(
+      execute_options = {
         query: query_string,
         context: context,
         subscription_topic: event.topic,
         operation_name: operation_name,
         variables: variables,
         root_value: object,
-      )
+      }
+      execute_options[:validate] = validate_update?(**execute_options)
+      result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)
       if subscriptions_context[:no_update]
         result = nil
@@ -142,6 +146,14 @@ module GraphQL
       result
     end
 
+    # Define this method to customize whether to validate
+    # this subscription when executing an update.
+    #
+    # @return [Boolean] defaults to `true`, or false if `validate: false` is provided.
+    def validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:)
+      @validate_update
+    end
+
     # Run the update query for this subscription and deliver it
     # @see {#execute_update}
     # @see {#deliver}

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,15 +17,21 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         tracer.trace(platform_key, service: service_name) do |span|
           span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
+          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = if operations.empty?
+
+            resource = if operations.empty?
               first_query = data[:multiplex].queries.first
               fallback_transaction_name(first_query && first_query.context)
             else
               operations
             end
+            span.resource = resource if resource
 
             # For top span of query, set the analytics sample rate tag, if available.
             if analytics_enabled?

data/lib/graphql/types/iso_8601_date.rb

@@ -14,6 +14,7 @@ module GraphQL
     # own Date type.
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
       # @param value [Date,Time,DateTime,String]
       # @return [String]
@@ -22,7 +23,7 @@ module GraphQL
       end
 
       # @param str_value [String, Date, DateTime, Time]
-      # @return [Date]
+      # @return [Date, nil]
       def self.coerce_input(value, ctx)
         if value.is_a?(::Date)
           value
@@ -30,6 +31,8 @@ module GraphQL
           value.to_date
         elsif value.is_a?(::Time)
           value.to_date
+        elsif value.nil?
+          nil
         else
           Date.iso8601(value)
         end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -17,6 +17,7 @@ module GraphQL
     # own DateTime type.
     class ISO8601DateTime < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded datetime"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
       # It's not compatible with Rails' default,
       # i.e. ActiveSupport::JSON::Encoder.time_precision (3 by default)

data/lib/graphql/types/relay/base_connection.rb

@@ -10,6 +10,8 @@ module GraphQL
       # so you can extend your own `BaseObject` instead of `GraphQL::Schema::Object`.
       #
       # @example Implementation a connection and edge
+      #   class BaseObject < GraphQL::Schema::Object; end
+      #
       #   # Given some object in your app ...
       #   class Types::Post < BaseObject
       #   end
@@ -20,14 +22,22 @@ module GraphQL
       #
       #   # Then extend them for the object in your app
       #   class Types::PostEdge < Types::BaseEdge
-      #     node_type(Types::Post)
+      #     node_type Types::Post
       #   end
+      #
       #   class Types::PostConnection < Types::BaseConnection
-      #     edge_type(Types::PostEdge)
-      #     edges_nullable(true)
-      #     edge_nullable(true)
-      #     node_nullable(true)
-      #     has_nodes_field(true)
+      #     edge_type Types::PostEdge,
+      #               edges_nullable: true,
+      #               edge_nullable: true,
+      #               node_nullable: true,
+      #               nodes_field: true
+      #
+      #     # Alternatively, you can call the class methods followed by your edge type
+      #     # edges_nullable true
+      #     # edge_nullable true
+      #     # nodes_nullable true
+      #     # has_nodes_field true
+      #     # edge_type Types::PostEdge
       #   end
       #
       # @see Relay::BaseEdge for edge types

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.7
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-21 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -314,7 +314,6 @@ files:
 - lib/graphql/execution/interpreter/runtime.rb
 - lib/graphql/execution/lazy.rb
 - lib/graphql/execution/lazy/lazy_method_map.rb
-- lib/graphql/execution/lazy/resolve.rb
 - lib/graphql/execution/lookahead.rb
 - lib/graphql/execution/multiplex.rb
 - lib/graphql/execution_error.rb

data/lib/graphql/execution/lazy/resolve.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    class Lazy
-      # Helpers for dealing with data structures containing {Lazy} instances
-      # @api private
-      module Resolve
-        # Mutate `value`, replacing {Lazy} instances in place with their resolved values
-        # @return [void]
-
-        # This object can be passed like an array, but it doesn't allocate an
-        # array until it's used.
-        #
-        # There's one crucial difference: you have to _capture_ the result
-        # of `#<<`. (This _works_ with arrays but isn't required, since it has a side-effect.)
-        # @api private
-        module NullAccumulator
-          def self.<<(item)
-            [item]
-          end
-
-          def self.empty?
-            true
-          end
-        end
-
-        def self.resolve(value)
-          lazies = resolve_in_place(value)
-          deep_sync(lazies)
-        end
-
-        def self.resolve_in_place(value)
-          acc = each_lazy(NullAccumulator, value)
-
-          if acc.empty?
-            Lazy::NullResult
-          else
-            Lazy.new {
-              acc.each_with_index { |ctx, idx|
-                acc[idx] = ctx.value.value
-              }
-              resolve_in_place(acc)
-            }
-          end
-        end
-
-        # If `value` is a collection,
-        # add any {Lazy} instances in the collection
-        # to `acc`
-        # @return [void]
-        def self.each_lazy(acc, value)
-          case value
-          when Hash
-            value.each do |key, field_result|
-              acc = each_lazy(acc, field_result)
-            end
-          when Array
-            value.each do |field_result|
-              acc = each_lazy(acc, field_result)
-            end
-          when Query::Context::SharedMethods
-            field_value = value.value
-            case field_value
-            when Lazy
-              acc = acc << value
-            when Enumerable # shortcut for Hash & Array
-              acc = each_lazy(acc, field_value)
-            end
-          end
-
-          acc
-        end
-
-        # Traverse `val`, triggering resolution for each {Lazy}.
-        # These {Lazy}s are expected to mutate their owner data structures
-        # during resolution! (They're created with the `.then` calls in `resolve_in_place`).
-        # @return [void]
-        def self.deep_sync(val)
-          case val
-          when Lazy
-            deep_sync(val.value)
-          when Array
-            val.each { |v| deep_sync(v.value) }
-          when Hash
-            val.each { |k, v| deep_sync(v.value) }
-          end
-        end
-      end
-    end
-  end
-end