graphql 2.0.25 → 2.0.27

data/lib/graphql/language/parser.y

@@ -150,6 +150,7 @@ rule
     | REPEATABLE
     | TRUE
     | FALSE
+    | NULL
     | operation_type
     | schema_keyword
 

data/lib/graphql/schema/addition.rb

@@ -258,6 +258,12 @@ module GraphQL
             end
             path.pop
           end
+
+          if type.kind.enum?
+            type.all_enum_value_definitions.each do |value_definition|
+              add_directives_from(value_definition)
+            end
+          end
         end
       end
     end

data/lib/graphql/schema/field.rb

@@ -92,7 +92,7 @@ module GraphQL
       # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
       # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
       # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration
-      # @return [GraphQL::Schema:Field] an instance of `self
+      # @return [GraphQL::Schema:Field] an instance of `self`
       # @see {.initialize} for other options
       def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
         if (resolver_class = resolver || mutation || subscription)

data/lib/graphql/schema/resolver.rb

@@ -65,19 +65,20 @@ module GraphQL
       # @api private
       def resolve_with_support(**args)
         # First call the ready? hook which may raise
-        ready_val = if args.any?
+        raw_ready_val = if args.any?
           ready?(**args)
         else
           ready?
         end
-        context.query.after_lazy(ready_val) do |is_ready, ready_early_return|
-          if ready_early_return
+        context.query.after_lazy(raw_ready_val) do |ready_val|
+          if ready_val.is_a?(Array)
+            is_ready, ready_early_return = ready_val
             if is_ready != false
               raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
             else
               ready_early_return
             end
-          elsif is_ready
+          elsif ready_val
             # Then call each prepare hook, which may return a different value
             # for that argument, or may return a lazy object
             load_arguments_val = load_arguments(args)
@@ -85,21 +86,22 @@ module GraphQL
               @prepared_arguments = loaded_args
               Schema::Validator.validate!(self.class.validators, object, context, loaded_args, as: @field)
               # Then call `authorized?`, which may raise or may return a lazy object
-              authorized_val = if loaded_args.any?
+              raw_authorized_val = if loaded_args.any?
                 authorized?(**loaded_args)
               else
                 authorized?
               end
-              context.query.after_lazy(authorized_val) do |(authorized_result, early_return)|
+              context.query.after_lazy(raw_authorized_val) do |authorized_val|
                 # If the `authorized?` returned two values, `false, early_return`,
                 # then use the early return value instead of continuing
-                if early_return
+                if authorized_val.is_a?(Array)
+                  authorized_result, early_return = authorized_val
                   if authorized_result == false
                     early_return
                   else
                     raise "Unexpected result from #authorized? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{early_return.inspect}]"
                   end
-                elsif authorized_result
+                elsif authorized_val
                   # Finally, all the hooks have passed, so resolve it
                   if loaded_args.any?
                     public_send(self.class.resolve_method, **loaded_args)

data/lib/graphql/schema/validator.rb

@@ -133,7 +133,7 @@ module GraphQL
             if all_errors.frozen? # It's empty
               all_errors = []
             end
-            interpolation_vars = { validated: validated.graphql_name }
+            interpolation_vars = { validated: validated.graphql_name, value: value.inspect }
             if errors.is_a?(String)
               all_errors << (errors % interpolation_vars)
             else

data/lib/graphql/tracing/data_dog_trace.rb

@@ -76,7 +76,7 @@ module GraphQL
         RUBY
       end
 
-      def execute_field(span_key = "execute_field", query:, field:, ast_node:, arguments:, object:)
+      def execute_field_span(span_key, query, field, ast_node, arguments, object)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?
           (field.trace.nil? && @trace_scalars) || field.trace
@@ -99,18 +99,31 @@ module GraphQL
               prepare_span_data = { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }
               prepare_span(span_key, prepare_span_data, span)
             end
-            super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+            yield
           end
         else
+          yield
+        end
+      end
+      def execute_field(query:, field:, ast_node:, arguments:, object:)
+        execute_field_span("execute_field", query, field, ast_node, arguments, object) do
           super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
         end
       end
 
       def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
-        execute_field("execute_field_lazy", query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        execute_field_span("execute_field_lazy", query, field, ast_node, arguments, object) do
+          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        end
       end
 
-      def authorized(object:, type:, query:, span_key: "authorized")
+      def authorized(query:, type:, object:)
+        authorized_span("authorized", object, type, query) do
+          super(query: query, type: type, object: object)
+        end
+      end
+
+      def authorized_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_authorized_key_cache[type]
         @tracer.trace(platform_key, service: @service_name) do |span|
           span.span_type = 'custom'
@@ -121,15 +134,29 @@ module GraphQL
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end
+          yield
+        end
+      end
+
+      def authorized_lazy(object:, type:, query:)
+        authorized_span("authorized_lazy", object, type, query) do
           super(query: query, type: type, object: object)
         end
       end
 
-      def authorized_lazy(**kwargs, &block)
-        authorized(span_key: "authorized_lazy", **kwargs, &block)
+      def resolve_type(object:, type:, query:)
+        resolve_type_span("resolve_type", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
       end
 
-      def resolve_type(object:, type:, query:, span_key: "resolve_type")
+      def resolve_type_lazy(object:, type:, query:)
+        resolve_type_span("resolve_type_lazy", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
+      end
+
+      def resolve_type_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_resolve_type_key_cache[type]
         @tracer.trace(platform_key, service: @service_name) do |span|
           span.span_type = 'custom'
@@ -140,14 +167,10 @@ module GraphQL
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end
-          super(query: query, type: type, object: object)
+          yield
         end
       end
 
-      def resolve_type_lazy(**kwargs, &block)
-        resolve_type(span_key: "resolve_type_lazy", **kwargs, &block)
-      end
-
       include PlatformTrace
 
       # Implement this method in a subclass to apply custom tags to datadog spans

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.25
+  version: 2.0.27
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-07 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips