graphql 1.11.4 → 1.11.8

data/lib/graphql/schema/argument.rb

@@ -45,7 +45,8 @@ module GraphQL
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
       # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, &definition_block)
+      # @param deprecation_reason [String]
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, deprecation_reason: nil, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -60,6 +61,7 @@ module GraphQL
         @ast_node = ast_node
         @from_resolver = from_resolver
         @method_access = method_access
+        self.deprecation_reason = deprecation_reason
 
         if definition_block
           if definition_block.arity == 1
@@ -89,6 +91,18 @@ module GraphQL
         end
       end
 
+      # @return [String] Deprecation reason for this argument
+      def deprecation_reason(text = nil)
+        if text
+          validate_deprecated_or_optional(null: @null, deprecation_reason: text)
+          @deprecation_reason = text
+        else
+          @deprecation_reason
+        end
+      end
+
+      alias_method :deprecation_reason=, :deprecation_reason
+
       def visible?(context)
         true
       end
@@ -143,15 +157,32 @@ module GraphQL
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end
+        if @deprecation_reason
+          argument.deprecation_reason = @deprecation_reason
+        end
         argument
       end
 
-      attr_writer :type
+      def type=(new_type)
+        validate_input_type(new_type)
+        # This isn't true for LateBoundTypes, but we can assume those will
+        # be updated via this codepath later in schema setup.
+        if new_type.respond_to?(:non_null?)
+          validate_deprecated_or_optional(null: !new_type.non_null?, deprecation_reason: deprecation_reason)
+        end
+        @type = new_type
+      end
 
       def type
-        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
-      rescue StandardError => err
-        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+        @type ||= begin
+          parsed_type = begin
+            Member::BuildType.parse_type(@type_expr, null: @null)
+          rescue StandardError => err
+            raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+          end
+          # Use the setter method to get validations
+          self.type = parsed_type
+        end
       end
 
       def statically_coercible?
@@ -186,6 +217,26 @@ module GraphQL
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
         end
       end
+
+      private
+
+      def validate_input_type(input_type)
+        if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
+          # Do nothing; assume this will be validated later
+        elsif input_type.kind.non_null? || input_type.kind.list?
+          validate_input_type(input_type.unwrap)
+        elsif !input_type.kind.input?
+          raise ArgumentError, "Invalid input type for #{path}: #{input_type.graphql_name}. Must be scalar, enum, or input object, not #{input_type.kind.name}."
+        else
+          # It's an input type, we're OK
+        end
+      end
+
+      def validate_deprecated_or_optional(null:, deprecation_reason:)
+        if deprecation_reason && !null
+          raise ArgumentError, "Required arguments cannot be deprecated: #{path}."
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/build_from_definition.rb

@@ -4,17 +4,24 @@ require "graphql/schema/build_from_definition/resolve_map"
 module GraphQL
   class Schema
     module BuildFromDefinition
+      if !String.method_defined?(:-@)
+        using GraphQL::StringDedupBackport
+      end
+
       class << self
         # @see {Schema.from_definition}
-        def from_definition(definition_string, default_resolve:, using: {}, relay: false, interpreter: true, parser: DefaultParser)
-          document = parser.parse(definition_string)
-          default_resolve ||= {}
-          Builder.build(document, default_resolve: default_resolve, relay: relay, using: using, interpreter: interpreter)
+        def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse(definition_string), **kwargs)
         end
-      end
 
-      # @api private
-      DefaultParser = GraphQL::Language::Parser
+        def from_definition_path(definition_path, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse_file(definition_path), **kwargs)
+        end
+
+        def from_document(document, default_resolve:, using: {}, relay: false, interpreter: true)
+          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using, interpreter: interpreter)
+        end
+      end
 
       # @api private
       module Builder
@@ -43,7 +50,7 @@ module GraphQL
             when GraphQL::Language::Nodes::EnumTypeDefinition
               types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve)
+              types[definition.name] = build_object_type(definition, type_resolver)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
               types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
@@ -111,11 +118,11 @@ module GraphQL
             end
 
             if default_resolve.respond_to?(:resolve_type)
-              define_singleton_method(:resolve_type) do |*args|
-                default_resolve.resolve_type(*args)
+              def self.resolve_type(*args)
+                self.definition_default_resolve.resolve_type(*args)
               end
             else
-              define_singleton_method(:resolve_type) do |*args|
+              def self.resolve_type(*args)
                 NullResolveType.call(*args)
               end
             end
@@ -141,6 +148,20 @@ module GraphQL
 
             # Empty `orphan_types` -- this will make unreachable types ... unreachable.
             own_orphan_types.clear
+
+            class << self
+              attr_accessor :definition_default_resolve
+            end
+
+            self.definition_default_resolve = default_resolve
+
+            def definition_default_resolve
+              self.class.definition_default_resolve
+            end
+
+            def self.inherited(child_class)
+              child_class.definition_default_resolve = self.definition_default_resolve
+            end
           end
         end
 
@@ -176,23 +197,27 @@ module GraphQL
         end
 
         def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+          builder = self
           Class.new(GraphQL::Schema::Scalar) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
 
             if default_resolve.respond_to?(:coerce_input)
-              define_singleton_method(:coerce_input) do |val, ctx|
-                default_resolve.coerce_input(self, val, ctx)
-              end
-
-              define_singleton_method(:coerce_result) do |val, ctx|
-                default_resolve.coerce_result(self, val, ctx)
-              end
+              # Put these method definitions in another method to avoid retaining `type_resolve`
+              # from this method's bindiing
+              builder.build_scalar_type_coerce_method(self, :coerce_input, default_resolve)
+              builder.build_scalar_type_coerce_method(self, :coerce_result, default_resolve)
             end
           end
         end
 
+        def build_scalar_type_coerce_method(scalar_class, method_name, default_definition_resolve)
+          scalar_class.define_singleton_method(method_name) do |val, ctx|
+            default_definition_resolve.public_send(method_name, self, val, ctx)
+          end
+        end
+
         def build_union_type(union_type_definition, type_resolver)
           Class.new(GraphQL::Schema::Union) do
             graphql_name(union_type_definition.name)
@@ -202,13 +227,10 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:)
+        def build_object_type(object_type_definition, type_resolver)
           builder = self
-          type_def = nil
-          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
 
           Class.new(GraphQL::Schema::Object) do
-            type_def = self
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
@@ -218,7 +240,7 @@ module GraphQL
               implements(interface_defn)
             end
 
-            builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)
+            builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
@@ -247,13 +269,16 @@ module GraphQL
           end
         end
 
+        NO_DEFAULT_VALUE = {}.freeze
+
         def build_arguments(type_class, arguments, type_resolver)
           builder = self
 
           arguments.each do |argument_defn|
-            default_value_kwargs = {}
-            if !argument_defn.default_value.nil?
-              default_value_kwargs[:default_value] = builder.build_default_value(argument_defn.default_value)
+            default_value_kwargs = if !argument_defn.default_value.nil?
+              { default_value: builder.build_default_value(argument_defn.default_value) }
+            else
+              NO_DEFAULT_VALUE
             end
 
             type_class.argument(
@@ -261,6 +286,7 @@ module GraphQL
               type: type_resolver.call(argument_defn.type),
               required: false,
               description: argument_defn.description,
+              deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
               method_access: false,
@@ -295,10 +321,10 @@ module GraphQL
         def build_fields(owner, field_definitions, type_resolver, default_resolve:)
           builder = self
 
-          field_definitions.map do |field_definition|
+          field_definitions.each do |field_definition|
             type_name = resolve_type_name(field_definition.type)
-            resolve_method_name = "resolve_field_#{field_definition.name}"
-            owner.field(
+            resolve_method_name = -"resolve_field_#{field_definition.name}"
+            schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
@@ -310,16 +336,19 @@ module GraphQL
               method_conflict_warning: false,
               camelize: false,
               resolver_method: resolve_method_name,
-            ) do
-              builder.build_arguments(self, field_definition.arguments, type_resolver)
-
-              # Don't do this for interfaces
-              if default_resolve
-                owner.send(:define_method, resolve_method_name) do |**args|
-                  field_instance = self.class.get_field(field_definition.name)
-                  default_resolve.call(field_instance, object, args, context)
+            )
+
+            builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
+
+            # Don't do this for interfaces
+            if default_resolve
+              owner.class_eval <<-RUBY, __FILE__, __LINE__
+                # frozen_string_literal: true
+                def #{resolve_method_name}(**args)
+                  field_instance = self.class.get_field("#{field_definition.name}")
+                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
                 end
-              end
+              RUBY
             end
           end
         end

data/lib/graphql/schema/default_type_error.rb

@@ -8,6 +8,8 @@ module GraphQL
           ctx.errors << type_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
+        when GraphQL::IntegerDecodingError
+          nil
         end
       end
     end

data/lib/graphql/schema/directive/deprecated.rb

@@ -4,7 +4,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       class Deprecated < GraphQL::Schema::Directive
         description "Marks an element of a GraphQL schema as no longer supported."
-        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE)
+        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE, GraphQL::Schema::Directive::ARGUMENT_DEFINITION, GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION)
 
         reason_description = "Explains why this element was deprecated, usually also including a "\
         "suggestion for how to access supported similar data. Formatted "\

data/lib/graphql/schema/field.rb

@@ -203,7 +203,7 @@ module GraphQL
       # @param broadcastable [Boolean] Whether or not this field can be distributed in subscription broadcasts
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], 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, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, 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, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -250,7 +250,7 @@ module GraphQL
         method_name = method || hash_key || name_s
         resolver_method ||= name_s.to_sym
 
-        @method_str = method_name.to_s
+        @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
         @resolver_method = resolver_method
         @complexity = complexity
@@ -274,7 +274,7 @@ module GraphQL
           if arg.is_a?(Hash)
             argument(name: name, **arg)
           else
-            own_arguments[name] = arg
+            add_argument(arg)
           end
         end
 
@@ -282,7 +282,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         # Do this last so we have as much context as possible when initializing them:
-        @extensions = []
+        @extensions = EMPTY_ARRAY
         if extensions.any?
           self.extensions(extensions)
         end
@@ -343,6 +343,9 @@ module GraphQL
           # Read the value
           @extensions
         else
+          if @extensions.frozen?
+            @extensions = @extensions.dup
+          end
           new_extensions.each do |extension|
             if extension.is_a?(Hash)
               extension = extension.to_a[0]
@@ -380,6 +383,9 @@ module GraphQL
           # Read the value
           @extras
         else
+          if @extras.frozen?
+            @extras = @extras.dup
+          end
           # Append to the set of extras on this field
           @extras.concat(new_extras)
         end
@@ -719,32 +725,42 @@ module GraphQL
         if @extensions.empty?
           yield(obj, args)
         else
-          # Save these so that the originals can be re-given to `after_resolve` handlers.
-          original_args = args
-          original_obj = obj
-
-          memos = []
-          value = run_extensions_before_resolve(memos, obj, args, ctx) do |extended_obj, extended_args|
-            yield(extended_obj, extended_args)
+          # This is a hack to get the _last_ value for extended obj and args,
+          # in case one of the extensions doesn't `yield`.
+          # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
+          extended = { args: args, obj: obj, memos: nil }
+          value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
+            yield(obj, args)
           end
 
+          extended_obj = extended[:obj]
+          extended_args = extended[:args]
+          memos = extended[:memos] || EMPTY_HASH
+
           ctx.schema.after_lazy(value) do |resolved_value|
-            @extensions.each_with_index do |ext, idx|
+            idx = 0
+            @extensions.each do |ext|
               memo = memos[idx]
               # TODO after_lazy?
-              resolved_value = ext.after_resolve(object: original_obj, arguments: original_args, context: ctx, value: resolved_value, memo: memo)
+              resolved_value = ext.after_resolve(object: extended_obj, arguments: extended_args, context: ctx, value: resolved_value, memo: memo)
+              idx += 1
             end
             resolved_value
           end
         end
       end
 
-      def run_extensions_before_resolve(memos, obj, args, ctx, idx: 0)
+      def run_extensions_before_resolve(obj, args, ctx, extended, idx: 0)
         extension = @extensions[idx]
         if extension
           extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
-            memos << memo
-            run_extensions_before_resolve(memos, extended_obj, extended_args, ctx, idx: idx + 1) { |o, a| yield(o, a) }
+            if memo
+              memos = extended[:memos] ||= {}
+              memos[idx] = memo
+            end
+            extended[:obj] = extended_obj
+            extended[:args] = extended_args
+            run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }
           end
         else
           yield(obj, args)

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

@@ -18,10 +18,11 @@ module GraphQL
           next_args.delete(:last)
           next_args.delete(:before)
           next_args.delete(:after)
-          yield(object, next_args)
+          yield(object, next_args, arguments)
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
+          original_arguments = memo
           # rename some inputs to avoid conflicts inside the block
           maybe_lazy = value
           value = nil
@@ -37,10 +38,10 @@ module GraphQL
               # update the connection with some things that may not have been provided
               value.context ||= context
               value.parent ||= object.object
-              value.first_value ||= arguments[:first]
-              value.after_value ||= arguments[:after]
-              value.last_value ||= arguments[:last]
-              value.before_value ||= arguments[:before]
+              value.first_value ||= original_arguments[:first]
+              value.after_value ||= original_arguments[:after]
+              value.last_value ||= original_arguments[:last]
+              value.before_value ||= original_arguments[:before]
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size
               end
@@ -50,7 +51,7 @@ module GraphQL
               value
             elsif context.schema.new_connections?
               wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-              context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
+              context.schema.connections.wrap(field, object.object, value, original_arguments, context, wrappers: wrappers)
             else
               if object.is_a?(GraphQL::Schema::Object)
                 object = object.object
@@ -58,7 +59,7 @@ module GraphQL
               connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
               connection_class.new(
                 value,
-                arguments,
+                original_arguments,
                 field: field,
                 max_page_size: field.max_page_size,
                 parent: object,