graphql 2.0.6 → 2.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c31ecaae04f8ea6bca65c031a2a41d124d8a1e1dade016decfb047cae3f900ae
-  data.tar.gz: af77a6ac50b38ca0d23a08da8f63fea1ca8f14ef11ccda56de55e678518380c1
+  metadata.gz: 8b34cec1ffb7358b467f2fb7c00134db084793d9eb1ebe22f38f351435607c9b
+  data.tar.gz: d15754c440968f51715c0a71f3c23ef1c5fd075793c0de11aae6477976b5aa14
 SHA512:
-  metadata.gz: a6038fd4fe140b2196011e14cc61ba8b0ad72008b3cbe9d317bc87996fe6b42f7f289e188cd0d8c22a9d5f08c558d9774fa3533690355a16258b8276ad885e53
-  data.tar.gz: ff7c5db4532240f9c11d7f3008441f27c5b3a6948cfe942eaf337711436fe9c678de913a849a2e627689a15a08bb2f90f9a345185945308669447ec31dd61027
+  metadata.gz: f2ef024af0f5e1e261fe7b998e27d664df5f92127ffb2874135a6d7b1662763a4e2661634dd46cc67dd624b9fc8291ce1bd3488a460566bc346f9cd6edc86b43
+  data.tar.gz: 635165d9129c2c49510fd481a2161cf425f91ff016bcdb28b8955d1c818d66885a6f7d90c5210e4433ada541d6e116b3137cb12dbdcc44c32229ac564d266b64

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/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/schema/field.rb

@@ -248,7 +248,10 @@ module GraphQL
 
         method_name = method || name_s
         @dig_keys = dig
-        @hash_key = hash_key
+        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
@@ -639,8 +642,10 @@ module GraphQL
 
               inner_object = obj.object
 
-              if @hash_key
-                inner_object[@hash_key]
+              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)

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
@@ -977,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/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.6"
+  VERSION = "2.0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.7
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-14 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