graphql 1.10.6 → 1.10.11

data/lib/graphql/internal_representation/visit.rb

@@ -23,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -49,7 +49,7 @@ module GraphQL
           subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
           # This only supports directives from parsing,
           # use a custom printer to add to this list.
-          directives: @schema.ast_node ? @schema.ast_node.directives : [],
+          directives: ast_directives(@schema),
         )
       end
 
@@ -59,32 +59,26 @@ module GraphQL
           interfaces: warden.interfaces(object_type).sort_by(&:graphql_name).map { |iface| build_type_name_node(iface) },
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
+          directives: ast_directives(object_type),
         )
       end
 
       def build_field_node(field)
-        field_node = GraphQL::Language::Nodes::FieldDefinition.new(
+        GraphQL::Language::Nodes::FieldDefinition.new(
           name: field.graphql_name,
           arguments: build_argument_nodes(warden.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
+          directives: ast_directives(field),
         )
-
-        if field.deprecation_reason
-          field_node = field_node.merge_directive(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: field.deprecation_reason)]
-          )
-        end
-
-        field_node
       end
 
       def build_union_type_node(union_type)
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.graphql_name,
           description: union_type.description,
-          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) }
+          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          directives: ast_directives(union_type),
         )
       end
 
@@ -92,7 +86,8 @@ module GraphQL
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.graphql_name,
           description: interface_type.description,
-          fields: build_field_nodes(warden.fields(interface_type))
+          fields: build_field_nodes(warden.fields(interface_type)),
+          directives: ast_directives(interface_type),
         )
       end
 
@@ -103,29 +98,23 @@ module GraphQL
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
+          directives: ast_directives(enum_type),
         )
       end
 
       def build_enum_value_node(enum_value)
-        enum_value_node = GraphQL::Language::Nodes::EnumValueDefinition.new(
+        GraphQL::Language::Nodes::EnumValueDefinition.new(
           name: enum_value.graphql_name,
           description: enum_value.description,
+          directives: ast_directives(enum_value),
         )
-
-        if enum_value.deprecation_reason
-          enum_value_node = enum_value_node.merge_directive(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: enum_value.deprecation_reason)]
-          )
-        end
-
-        enum_value_node
       end
 
       def build_scalar_type_node(scalar_type)
         GraphQL::Language::Nodes::ScalarTypeDefinition.new(
           name: scalar_type.graphql_name,
           description: scalar_type.description,
+          directives: ast_directives(scalar_type),
         )
       end
 
@@ -141,6 +130,7 @@ module GraphQL
           description: argument.description,
           type: build_type_name_node(argument.type),
           default_value: default_value,
+          directives: ast_directives(argument),
         )
 
         argument_node
@@ -151,6 +141,7 @@ module GraphQL
           name: input_object.graphql_name,
           fields: build_argument_nodes(warden.arguments(input_object)),
           description: input_object.description,
+          directives: ast_directives(input_object),
         )
       end
 
@@ -292,6 +283,34 @@ module GraphQL
         (schema.subscription.nil? || schema.subscription.graphql_name == 'Subscription')
       end
 
+      def ast_directives(member)
+        ast_directives = member.ast_node ? member.ast_node.directives : []
+
+        # If this schema was built from IDL, it will already have `@deprecated` in `ast_node.directives`
+        if member.respond_to?(:deprecation_reason) &&
+            (reason = member.deprecation_reason) &&
+            ast_directives.none? { |d| d.name == "deprecated" }
+
+          arguments = []
+
+          if reason != GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
+            arguments << GraphQL::Language::Nodes::Argument.new(
+              name: "reason",
+              value: reason
+            )
+          end
+
+          ast_directives += [
+            GraphQL::Language::Nodes::Directive.new(
+              name: GraphQL::Directive::DeprecatedDirective.graphql_name,
+              arguments: arguments
+            )
+          ]
+        end
+
+        ast_directives
+      end
+
       attr_reader :schema, :warden, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end

data/lib/graphql/object_type.rb

@@ -88,7 +88,7 @@ module GraphQL
       interfaces.each do |iface|
         iface = BaseType.resolve_related_type(iface)
         if iface.is_a?(GraphQL::InterfaceType)
-          type_memberships << iface.type_membership_class.new(iface, self, options)
+          type_memberships << iface.type_membership_class.new(iface, self, **options)
         end
       end
     end

data/lib/graphql/relay/base_connection.rb

@@ -74,8 +74,6 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.

data/lib/graphql/schema.rb

@@ -101,14 +101,12 @@ module GraphQL
       # - Right away, if `value` is not registered with `lazy_resolve`
       # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
       # @api private
-      def after_lazy(value)
+      def after_lazy(value, &block)
         if lazy?(value)
           GraphQL::Execution::Lazy.new do
             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?
-            end
+            after_lazy(result, &block)
           end
         else
           yield(value) if block_given?
@@ -146,10 +144,10 @@ module GraphQL
       def after_any_lazies(maybe_lazies)
         if maybe_lazies.any? { |l| lazy?(l) }
           GraphQL::Execution::Lazy.all(maybe_lazies).then do |result|
-            yield
+            yield result
           end
         else
-          yield
+          yield maybe_lazies
         end
       end
     end
@@ -555,8 +553,17 @@ module GraphQL
     # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn, context = GraphQL::Query::NullContext)
-      @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn, context)
+      if context == GraphQL::Query::NullContext
+        @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
+        @possible_types.possible_types(type_defn, context)
+      else
+        # Use the incoming context to cache this instance --
+        # if it were cached on the schema, we'd have a memory leak
+        # https://github.com/rmosolgo/graphql-ruby/issues/2878
+        ns = context.namespace(:possible_types)
+        per_query_possible_types = ns[:possible_types] ||= GraphQL::Schema::PossibleTypes.new(self)
+        per_query_possible_types.possible_types(type_defn, context)
+      end
     end
 
     # @see [GraphQL::Schema::Warden] Resticted access to root types
@@ -863,8 +870,8 @@ module GraphQL
       # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
       # @see {#as_json}
       # @return [String]
-      def to_json(*args)
-        JSON.pretty_generate(as_json(*args))
+      def to_json(**args)
+        JSON.pretty_generate(as_json(**args))
       end
 
       # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -1382,7 +1389,7 @@ module GraphQL
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
@@ -1390,7 +1397,11 @@ module GraphQL
 
           after_lazy(first_resolved_type) do |resolved_type|
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind)) || resolved_type.is_a?(GraphQL::BaseType)
-              resolved_type
+              if resolved_value
+                [resolved_type, resolved_value]
+              else
+                resolved_type
+              end
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -1499,7 +1510,11 @@ module GraphQL
 
       # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
       def error_handler
-        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+        if defined?(@error_handler)
+          @error_handler
+        else
+          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
+        end
       end
 
       def lazy_resolve(lazy_class, value_method)

data/lib/graphql/schema/argument.rb

@@ -154,6 +154,12 @@ module GraphQL
         raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
       end
 
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+
+        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private

data/lib/graphql/schema/base_64_encoder.rb

@@ -13,6 +13,8 @@ module GraphQL
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
         Base64Bp.urlsafe_decode64(encoded_text)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end
     end
   end

data/lib/graphql/schema/enum.rb

@@ -23,6 +23,9 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
+      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      end
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
@@ -94,7 +97,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(GraphQL::EnumType::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
           end
         end
 
@@ -112,6 +115,11 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          super
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -47,6 +47,11 @@ module GraphQL
         @resolver_class
       end
 
+      # @return [Boolean] Is this field a predefined introspection field?
+      def introspection?
+        @introspection
+      end
+
       alias :mutation :resolver
 
       # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
@@ -551,34 +556,36 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, args, ctx)
-            # Apply field extensions
-            with_extensions(object, args, ctx) do |extended_obj, extended_args|
-              field_receiver = if @resolver_class
-                resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
-                  extended_obj.object
+          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
+            if is_authorized
+              # Apply field extensions
+              with_extensions(object, args, ctx) do |extended_obj, extended_args|
+                field_receiver = if @resolver_class
+                  resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
+                    extended_obj.object
+                  else
+                    extended_obj
+                  end
+                  @resolver_class.new(object: resolver_obj, context: ctx, field: self)
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
-              else
-                extended_obj
-              end
 
-              if field_receiver.respond_to?(@resolver_method)
-                # Call the method with kwargs, if there are any
-                if extended_args.any?
-                  field_receiver.public_send(@resolver_method, **extended_args)
+                if field_receiver.respond_to?(@resolver_method)
+                  # Call the method with kwargs, if there are any
+                  if extended_args.any?
+                    field_receiver.public_send(@resolver_method, **extended_args)
+                  else
+                    field_receiver.public_send(@resolver_method)
+                  end
                 else
-                  field_receiver.public_send(@resolver_method)
+                  resolve_field_method(field_receiver, extended_args, ctx)
                 end
-              else
-                resolve_field_method(field_receiver, extended_args, ctx)
               end
+            else
+              err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
-            ctx.schema.unauthorized_field(err)
           end
         rescue GraphQL::UnauthorizedFieldError => err
           err.field ||= self
@@ -663,10 +670,12 @@ module GraphQL
               loaded_value = if loads && !arg_defn.from_resolver?
                 if arg_defn.type.list?
                   loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
-                  maybe_lazies.concat(loaded_values)
+                  field_ctx.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, field_ctx.query.context)
                 end
+              elsif arg_defn.type.list? && value.is_a?(Array)
+                field_ctx.schema.after_any_lazies(value, &:itself)
               else
                 value
               end

data/lib/graphql/schema/input_object.rb

@@ -10,12 +10,13 @@ module GraphQL
 
       include GraphQL::Dig
 
-      def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
+      def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
         if ruby_kwargs
           @ruby_style_hash = ruby_kwargs
+          @arguments = arguments
         else
-          @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
+          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
           # Symbolized, underscored hash:
           @ruby_style_hash = @arguments.to_kwargs
         end
@@ -56,7 +57,7 @@ module GraphQL
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
 
-      # @return [GraphQL::Query::Arguments] The underlying arguments instance
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
@@ -208,10 +209,12 @@ module GraphQL
             return nil
           end
 
-          input_values = coerce_arguments(nil, value, ctx)
+          arguments = coerce_arguments(nil, value, ctx)
 
-          input_obj_instance = self.new(ruby_kwargs: input_values, context: ctx, defaults_used: nil)
-          input_obj_instance.prepare
+          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+            input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
+            input_obj_instance.prepare
+          end
         end
 
         # It's funny to think of a _result_ of an input object.

data/lib/graphql/schema/interface.rb

@@ -14,6 +14,7 @@ module GraphQL
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -74,6 +75,10 @@ module GraphQL
             if overridden_graphql_name
               child_class.graphql_name(overridden_graphql_name)
             end
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}