graphql 2.0.8 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a10c35ffd2541c0b387e2e7d127eea0d1e2b4559fbd637288296369c0be09d0d
-  data.tar.gz: 34bf4d3cc5ef08bfbc065f9cdff4690dfa4b3351d46e014422304b897b531189
+  metadata.gz: 39d95cd85a336ff82b22df87f496df97db11ecae05dbf80d090d5bb51445a499
+  data.tar.gz: b50ecc9d63922cbe1e7cbbd7d9a049528625584fb0bd6991918e867f8d6e2e45
 SHA512:
-  metadata.gz: afed371861c1dcca740f07940d7f8239e800723623d6a9eb664592b169568ab1d92e3c2ea1286ba40625e00be0b27584f94e2493479cfd119251831d90c3f0a0
-  data.tar.gz: 43e8362810fb7a48fcdec9f997a2b33c599e08c1276da79480e75c6fad456328775e71dc1317e98923a88b5e3169a5f9f3b491d09b943c49805d536071e0047f
+  metadata.gz: b404ea0ca0c0a1b4206330514da8d38c5e5f31abd4c93ebc696c91c2177f25e7f40703016742aeb6f8857f1bd208b9012778a21643a7ae08709bd08c994b31eb
+  data.tar.gz: 5d41fa5df69f4722bf0bffaca89675b77ff7cb4b1af863550bb5908e03135f82214f516c092b83273c3ff367d20c845a000db9d5bbf5f8e43a3db0a0640a0095

data/lib/graphql/analysis/ast/field_usage.rb

@@ -39,9 +39,11 @@ module GraphQL
               @used_deprecated_arguments << argument.definition.path
             end
 
+            next if argument.value.nil?
+
             if argument.definition.type.kind.input_object?
               extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument.definition.type.list? && !argument.value.nil?
+            elsif argument.definition.type.list?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }

data/lib/graphql/pagination/connection.rb

@@ -56,8 +56,9 @@ module GraphQL
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
-      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
+      # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given and no `default_page_size` is set.
+      # @param default_page_size [Integer, nil] A configured value to determine the result size when neither first or last are given.
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, default_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
         @parent = parent
         @context = context
@@ -76,6 +77,12 @@ module GraphQL
         else
           max_page_size
         end
+        @has_default_page_size_override = default_page_size != :not_given
+        @default_page_size = if default_page_size == :not_given
+          nil
+        else
+          default_page_size
+        end
       end
 
       def max_page_size=(new_value)
@@ -95,16 +102,36 @@ module GraphQL
         @has_max_page_size_override
       end
 
+      def default_page_size=(new_value)
+        @has_default_page_size_override = true
+        @default_page_size = new_value
+      end
+
+      def default_page_size
+        if @has_default_page_size_override
+          @default_page_size
+        else
+          context.schema.default_page_size
+        end
+      end
+
+      def has_default_page_size_override?
+        @has_default_page_size_override
+      end
+
       attr_writer :first
       # @return [Integer, nil]
       #   A clamped `first` value.
       #   (The underlying instance variable doesn't have limits on it.)
-      #   If neither `first` nor `last` is given, but `max_page_size` is present, max_page_size is used for first.
+      #   If neither `first` nor `last` is given, but `default_page_size` is
+      #   present, default_page_size is used for first. If `default_page_size`
+      #   is greater than `max_page_size``, it'll be clamped down to
+      #   `max_page_size`. If `default_page_size` is nil, use `max_page_size`.
       def first
         @first ||= begin
           capped = limit_pagination_argument(@first_value, max_page_size)
           if capped.nil? && last.nil?
-            capped = max_page_size
+            capped = limit_pagination_argument(default_page_size, max_page_size) || max_page_size
           end
           capped
         end

data/lib/graphql/pagination/connections.rb

@@ -70,6 +70,7 @@ module GraphQL
             parent: parent,
             field: field,
             max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            default_page_size: field.has_default_page_size? ? field.default_page_size : context.schema.default_page_size,
             first: arguments[:first],
             after: arguments[:after],
             last: arguments[:last],

data/lib/graphql/schema/field/connection_extension.rb

@@ -47,6 +47,9 @@ module GraphQL
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size
               end
+              if field.has_default_page_size? && !value.has_default_page_size_override?
+                value.default_page_size = field.default_page_size
+              end
               if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
                 value.edge_class = custom_t
               end
@@ -64,6 +67,7 @@ module GraphQL
                 original_arguments,
                 field: field,
                 max_page_size: field.max_page_size,
+                default_page_size: field.default_page_size,
                 parent: object,
                 context: context,
               )

data/lib/graphql/schema/field.rb

@@ -200,6 +200,7 @@ module GraphQL
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
+      # @param default_page_size [Integer, nil] For connections, the default number of items to return from this field, or `nil` to return unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver.
       # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
@@ -215,7 +216,7 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: :not_given, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: :not_given, default_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: :not_given, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -269,6 +270,8 @@ module GraphQL
         @connection = connection
         @has_max_page_size = max_page_size != :not_given
         @max_page_size = max_page_size == :not_given ? nil : max_page_size
+        @has_default_page_size = default_page_size != :not_given
+        @default_page_size = default_page_size == :not_given ? nil : default_page_size
         @introspection = introspection
         @extras = extras
         if !broadcastable.nil?
@@ -464,11 +467,11 @@ module GraphQL
           end
 
           if max_possible_page_size.nil?
-            max_possible_page_size = max_page_size || query.schema.default_max_page_size
+            max_possible_page_size = default_page_size || query.schema.default_page_size || max_page_size || query.schema.default_max_page_size
           end
 
           if max_possible_page_size.nil?
-            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `max_page_size` or `default_max_page_size`"
+            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `default_page_size`, `max_page_size` or `default_max_page_size`"
           else
             metadata_complexity = 0
             lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
@@ -496,7 +499,13 @@ module GraphQL
           case defined_complexity
           when Proc
             arguments = query.arguments_for(nodes.first, self)
-            defined_complexity.call(query.context, arguments.keyword_arguments, child_complexity)
+            if arguments.is_a?(GraphQL::ExecutionError)
+              return child_complexity
+            elsif arguments.respond_to?(:keyword_arguments)
+              arguments = arguments.keyword_arguments
+            end
+
+            defined_complexity.call(query.context, arguments, child_complexity)
           when Numeric
             defined_complexity + child_complexity
           else
@@ -539,6 +548,16 @@ module GraphQL
         @max_page_size || (@resolver_class && @resolver_class.max_page_size)
       end
 
+      # @return [Boolean] True if this field's {#default_page_size} should override the schema default.
+      def has_default_page_size?
+        @has_default_page_size || (@resolver_class && @resolver_class.has_default_page_size?)
+      end
+
+      # @return [Integer, nil] Applied to connections if {#has_default_page_size?}
+      def default_page_size
+        @default_page_size || (@resolver_class && @resolver_class.default_page_size)
+      end
+
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 

data/lib/graphql/schema/resolver.rb

@@ -328,6 +328,27 @@ module GraphQL
           (!!defined?(@max_page_size)) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
         end
 
+        # Get or set the `default_page_size:` which will be configured for fields using this resolver
+        # (`nil` means "unlimited default page size".)
+        # @param default_page_size [Integer, nil] Set a new value
+        # @return [Integer, nil] The `default_page_size` assigned to fields that use this resolver
+        def default_page_size(new_default_page_size = :not_given)
+          if new_default_page_size != :not_given
+            @default_page_size = new_default_page_size
+          elsif defined?(@default_page_size)
+            @default_page_size
+          elsif superclass.respond_to?(:default_page_size)
+            superclass.default_page_size
+          else
+            nil
+          end
+        end
+
+        # @return [Boolean] `true` if this resolver or a superclass has an assigned `default_page_size`
+        def has_default_page_size?
+          (!!defined?(@default_page_size)) || (superclass.respond_to?(:has_default_page_size?) && superclass.has_default_page_size?)
+        end
+
         # A non-normalized type configuration, without `null` applied
         def type_expr
           @type_expr || (superclass.respond_to?(:type_expr) ? superclass.type_expr : nil)

data/lib/graphql/schema.rb

@@ -506,6 +506,14 @@ module GraphQL
         end
       end
 
+      def default_page_size(new_default_page_size = nil)
+        if new_default_page_size
+          @default_page_size = new_default_page_size
+        else
+          @default_page_size || find_inherited_value(:default_page_size)
+        end
+      end
+
       def query_execution_strategy(new_query_execution_strategy = nil)
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy

data/lib/graphql/tracing/opentelemetry_tracing.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class OpenTelemetryTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => 'graphql.lex',
+        'parse' => 'graphql.parse',
+        'validate' => 'graphql.validate',
+        'analyze_query' => 'graphql.analyze_query',
+        'analyze_multiplex' => 'graphql.analyze_multiplex',
+        'execute_query' => 'graphql.execute_query',
+        'execute_query_lazy' => 'graphql.execute_query_lazy',
+        'execute_multiplex' => 'graphql.execute_multiplex'
+      }
+
+      def platform_trace(platform_key, key, data)
+        return yield if platform_key.nil?
+
+        tracer.in_span(platform_key, attributes: attributes_for(key, data)) do |span, _context|
+          yield.tap do |response|
+            errors = response[:errors]&.compact&.map { |e| e.to_h }&.to_json if key == 'validate'
+            unless errors.nil?
+              span.add_event(
+                'graphql.validation.error',
+                attributes: {
+                  'message' => errors
+                }
+              )
+            end
+          end
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
+
+      private
+
+      def tracer
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.tracer
+      end
+
+      def config
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.config
+      end
+
+      def platform_key_enabled?(ctx, key)
+        return false unless config[key]
+
+        ns = ctx.namespace(:opentelemetry)
+        return true if ns.empty? # restores original behavior so that keys are returned if tracing is not set in context.
+        return false unless ns.key?(key) && ns[key]
+
+        return true
+      end
+
+      def attributes_for(key, data)
+        attributes = {}
+        case key
+        when 'execute_query'
+          attributes['selected_operation_name'] = data[:query].selected_operation_name if data[:query].selected_operation_name
+          attributes['selected_operation_type'] = data[:query].selected_operation.operation_type
+          attributes['query_string'] = data[:query].query_string
+        end
+        attributes
+      end
+
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+
+        cache.fetch(key) do
+          cache[key] = if trace_phase == :field
+            return unless platform_key_enabled?(ctx, :enable_platform_field)
+
+            yield
+          elsif trace_phase == :authorized
+            return unless platform_key_enabled?(ctx, :enable_platform_authorized)
+
+            yield
+          elsif trace_phase == :resolve_type
+            return unless platform_key_enabled?(ctx, :enable_platform_resolve_type)
+
+            yield
+          else
+            raise "Unknown trace phase"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -45,7 +45,7 @@ module GraphQL
 
             platform_key = if trace_field
               context = data.fetch(:query).context
-              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+              cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
             else
               nil
             end
@@ -61,14 +61,14 @@ module GraphQL
         when "authorized", "authorized_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
+          platform_key = cached_platform_key(context, type, :authorized) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
+          platform_key = cached_platform_key(context, type, :resolve_type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -116,7 +116,7 @@ module GraphQL
       # If the key isn't present, the given block is called and the result is cached for `key`.
       #
       # @return [String]
-      def cached_platform_key(ctx, key)
+      def cached_platform_key(ctx, key, trace_phase)
         cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
         cache.fetch(key) { cache[key] = yield }
       end

data/lib/graphql/tracing.rb

@@ -8,6 +8,7 @@ require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
 require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
+require "graphql/tracing/opentelemetry_tracing"
 
 if defined?(PrometheusExporter::Server)
   require "graphql/tracing/prometheus_tracing/graphql_collector"

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.0.9
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-24 00:00:00.000000000 Z
+date: 2022-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -538,6 +538,7 @@ files:
 - lib/graphql/tracing/data_dog_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_tracing.rb
+- lib/graphql/tracing/opentelemetry_tracing.rb
 - lib/graphql/tracing/platform_tracing.rb
 - lib/graphql/tracing/prometheus_tracing.rb
 - lib/graphql/tracing/prometheus_tracing/graphql_collector.rb