graphql 1.11.3 → 1.12.0

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

@@ -4,7 +4,7 @@ module GraphQL
   class Schema
     class Field
       class ScopeExtension < GraphQL::Schema::FieldExtension
-        def after_resolve(value:, context:, **rest)
+        def after_resolve(object:, arguments:, context:, value:, memo:)
           if value.nil?
             value
           else

data/lib/graphql/schema/input_object.rb

@@ -7,6 +7,7 @@ module GraphQL
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
       extend GraphQL::Schema::Member::ValidatesInput
+      extend GraphQL::Schema::Member::HasValidators
 
       include GraphQL::Dig
 
@@ -37,14 +38,15 @@ module GraphQL
                 load_application_object(arg_defn, loads, value, context)
               end
               maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
-                @ruby_style_hash[ruby_kwargs_key] = loaded_value
+                overwrite_argument(ruby_kwargs_key, loaded_value)
               end
             end
 
             # Weirdly, procs are applied during coercion, but not methods.
             # Probably because these methods require a `self`.
             if arg_defn.prepare.is_a?(Symbol) || context.nil? || !context.interpreter?
-              @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              overwrite_argument(ruby_kwargs_key, prepared_value)
             end
           end
         end
@@ -74,6 +76,9 @@ module GraphQL
       def prepare
         if context
           context.schema.after_any_lazies(@maybe_lazies) do
+            object = context[:current_object]
+            # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+            Schema::Validator.validate!(self.class.validators, object, context, @ruby_style_hash, as: self.class)
             self
           end
         else
@@ -126,9 +131,11 @@ module GraphQL
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
           method_name = argument_defn.keyword
-          define_method(method_name) do
-            self[method_name]
-          end
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
         end
 
         def to_graphql
@@ -166,17 +173,10 @@ module GraphQL
             return result
           end
 
-          input = begin
-            input.to_h
-          rescue
-            begin
-              # Handle ActionController::Parameters:
-              input.to_unsafe_h
-            rescue
-              # We're not sure it'll act like a hash, so reject it:
-              result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-              return result
-            end
+          if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
+            # We're not sure it'll act like a hash, so reject it:
+            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return result
           end
 
           # Inject missing required arguments
@@ -188,16 +188,19 @@ module GraphQL
             m
           end
 
-          input.merge(missing_required_inputs).each do |argument_name, value|
-            argument = warden.get_argument(self, argument_name)
-            # Items in the input that are unexpected
-            unless argument
-              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              next
+
+          [input, missing_required_inputs].each do |args_to_validate|
+            args_to_validate.each do |argument_name, value|
+              argument = warden.get_argument(self, argument_name)
+              # Items in the input that are unexpected
+              unless argument
+                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+                next
+              end
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
             end
-            # Items in the input that are expected, but have invalid values
-            argument_result = argument.type.validate_input(value, ctx)
-            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result
@@ -238,6 +241,16 @@ module GraphQL
           result
         end
       end
+
+      private
+
+      def overwrite_argument(key, value)
+        # Argument keywords come in frozen from the interpreter, dup them before modifying them.
+        if @ruby_style_hash.frozen?
+          @ruby_style_hash = @ruby_style_hash.dup
+        end
+        @ruby_style_hash[key] = value
+      end
     end
   end
 end

data/lib/graphql/schema/interface.rb

@@ -15,6 +15,7 @@ module GraphQL
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -30,7 +31,7 @@ module GraphQL
 
         # The interface is accessible if any of its possible types are accessible
         def accessible?(context)
-          context.schema.possible_types(self).each do |type|
+          context.schema.possible_types(self, context).each do |type|
             if context.schema.accessible?(type, context)
               return true
             end

data/lib/graphql/schema/late_bound_type.rb

@@ -16,11 +16,11 @@ module GraphQL
       end
 
       def to_non_null_type
-        GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
       end
 
       def to_list_type
-        GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::ListType.new(of_type: self)
       end
 
       def inspect

data/lib/graphql/schema/loader.rb

@@ -189,6 +189,7 @@ module GraphQL
             kwargs = {
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
               required: false,
               method_access: false,
               camelize: false,

data/lib/graphql/schema/member.rb

@@ -4,8 +4,11 @@ require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
+require 'graphql/schema/member/has_directives'
+require 'graphql/schema/member/has_deprecation_reason'
 require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/has_unresolved_type_error'
+require 'graphql/schema/member/has_validators'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
@@ -30,6 +33,7 @@ module GraphQL
       extend RelayShortcuts
       extend HasPath
       extend HasAstNode
+      extend HasDirectives
     end
   end
 end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -19,6 +19,7 @@ module GraphQL
         # @return [String]
         def graphql_name(new_name = nil)
           if new_name
+            GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
             overridden_graphql_name || default_graphql_name

data/lib/graphql/schema/member/build_type.rb

@@ -4,6 +4,10 @@ module GraphQL
     class Member
       # @api private
       module BuildType
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function
@@ -56,11 +60,11 @@ module GraphQL
               parse_type(type_expr.first, null: false)
             when 2
               inner_type, nullable_option = type_expr
-              if nullable_option.keys != [:null] || nullable_option.values != [true]
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
                 raise ArgumentError, LIST_TYPE_ERROR
               end
               list_type = true
-              parse_type(inner_type, null: true)
+              parse_type(inner_type, null: nullable_option[:null])
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
@@ -71,7 +75,7 @@ module GraphQL
             if type_expr.respond_to?(:graphql_definition)
               type_expr
             else
-              # Eg `String` => GraphQL::STRING_TYPE
+              # Eg `String` => GraphQL::Types::String
               parse_type(type_expr.name, null: true)
             end
           when Proc
@@ -162,10 +166,16 @@ module GraphQL
         end
 
         def underscore(string)
-          string
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-            .downcase
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
         end
       end
     end

data/lib/graphql/schema/member/has_arguments.rb

@@ -43,6 +43,7 @@ module GraphQL
         # @param arg_defn [GraphQL::Schema::Argument]
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
+          @own_arguments ||= {}
           own_arguments[arg_defn.name] = arg_defn
           arg_defn
         end
@@ -84,70 +85,87 @@ module GraphQL
         # @param context [GraphQL::Query::Context]
         # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
         def coerce_arguments(parent_object, values, context)
-          argument_values = {}
-          kwarg_arguments = {}
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
 
-          maybe_lazies = []
-          arg_lazies = arg_defns.map do |arg_name, arg_defn|
-            arg_key = arg_defn.keyword
-            has_value = false
-            default_used = false
-            if values.key?(arg_name)
-              has_value = true
-              value = values[arg_name]
-            elsif values.key?(arg_key)
-              has_value = true
-              value = values[arg_key]
-            elsif arg_defn.default_value?
-              has_value = true
-              value = arg_defn.default_value
-              default_used = true
-            end
-
-            if has_value
-              loads = arg_defn.loads
-              loaded_value = nil
-              if loads && !arg_defn.from_resolver?
-                loaded_value = if arg_defn.type.list?
-                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
-                  context.schema.after_any_lazies(loaded_values) { |result| result }
-                else
-                  load_application_object(arg_defn, loads, value, context)
-                end
+          if arg_defns.empty?
+            GraphQL::Execution::Interpreter::Arguments::EMPTY
+          else
+            argument_values = {}
+            arg_lazies = arg_defns.map do |arg_name, arg_defn|
+              arg_key = arg_defn.keyword
+              has_value = false
+              default_used = false
+              if values.key?(arg_name)
+                has_value = true
+                value = values[arg_name]
+              elsif values.key?(arg_key)
+                has_value = true
+                value = values[arg_key]
+              elsif arg_defn.default_value?
+                has_value = true
+                value = arg_defn.default_value
+                default_used = true
               end
 
-              coerced_value = if loaded_value
-                loaded_value
-              else
-                context.schema.error_handler.with_error_handling(context) do
+              if has_value
+                loads = arg_defn.loads
+                loaded_value = nil
+                coerced_value = context.schema.error_handler.with_error_handling(context) do
                   arg_defn.type.coerce_input(value, context)
                 end
-              end
 
-              context.schema.after_lazy(coerced_value) do |coerced_value|
-                prepared_value = context.schema.error_handler.with_error_handling(context) do
-                  arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                # TODO this should probably be inside after_lazy
+                if loads && !arg_defn.from_resolver?
+                  loaded_value = if arg_defn.type.list?
+                    loaded_values = coerced_value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                    context.schema.after_any_lazies(loaded_values) { |result| result }
+                  else
+                    load_application_object(arg_defn, loads, coerced_value, context)
+                  end
+                end
+
+                coerced_value = if loaded_value
+                  loaded_value
+                else
+                  coerced_value
                 end
 
-                kwarg_arguments[arg_key] = prepared_value
-                # TODO code smell to access such a deeply-nested constant in a distant module
-                argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-                  value: prepared_value,
-                  definition: arg_defn,
-                  default_used: default_used,
-                )
+                context.schema.after_lazy(coerced_value) do |coerced_value|
+                  validate_directive_argument(arg_defn, coerced_value)
+                  prepared_value = context.schema.error_handler.with_error_handling(context) do
+                    arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                  end
+
+                  # TODO code smell to access such a deeply-nested constant in a distant module
+                  argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+                    value: prepared_value,
+                    definition: arg_defn,
+                    default_used: default_used,
+                  )
+                end
+              else
+                # has_value is false
+                validate_directive_argument(arg_defn, nil)
               end
             end
+
+            context.schema.after_any_lazies(arg_lazies) do
+              GraphQL::Execution::Interpreter::Arguments.new(
+                argument_values: argument_values,
+              )
+            end
           end
+        end
 
-          maybe_lazies.concat(arg_lazies)
-          context.schema.after_any_lazies(maybe_lazies) do
-            GraphQL::Execution::Interpreter::Arguments.new(
-              keyword_arguments: kwarg_arguments,
-              argument_values: argument_values,
-            )
+        # Usually, this is validated statically by RequiredArgumentsArePresent,
+        # but not for directives.
+        # TODO apply static validations on schema definitions?
+        def validate_directive_argument(arg_defn, value)
+          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+            if value.nil? && arg_defn.type.non_null?
+              raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
+            end
           end
         end
 
@@ -229,8 +247,9 @@ module GraphQL
           end
         end
 
+        NO_ARGUMENTS = {}.freeze
         def own_arguments
-          @own_arguments ||= {}
+          @own_arguments || NO_ARGUMENTS
         end
       end
     end

data/lib/graphql/schema/member/has_deprecation_reason.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDeprecationReason
+        # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
+        def deprecation_reason
+          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
+          dir && dir.arguments[:reason]
+        end
+
+        # Set the deprecation reason for this member, or remove it by assigning `nil`
+        # @param text [String, nil]
+        def deprecation_reason=(text)
+          if text.nil?
+            remove_directive(GraphQL::Schema::Directive::Deprecated)
+          else
+            directive(GraphQL::Schema::Directive::Deprecated, reason: text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/has_directives.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDirectives
+        # Create an instance of `dir_class` for `self`, using `options`.
+        #
+        # It removes a previously-attached instance of `dir_class`, if there is one.
+        #
+        # @return [void]
+        def directive(dir_class, **options)
+          @own_directives ||= []
+          remove_directive(dir_class)
+          @own_directives << dir_class.new(self, **options)
+          nil
+        end
+
+        # Remove an attached instance of `dir_class`, if there is one
+        # @param dir_class [Class<GraphQL::Schema::Directive>]
+        # @return [viod]
+        def remove_directive(dir_class)
+          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          nil
+        end
+
+        NO_DIRECTIVES = [].freeze
+
+        def directives
+          case self
+          when Class
+            inherited_directives = if superclass.respond_to?(:directives)
+              superclass.directives
+            else
+              NO_DIRECTIVES
+            end
+            if inherited_directives.any? && @own_directives
+              dirs = []
+              merge_directives(dirs, inherited_directives)
+              merge_directives(dirs, @own_directives)
+              dirs
+            elsif @own_directives
+              @own_directives
+            elsif inherited_directives.any?
+              inherited_directives
+            else
+              NO_DIRECTIVES
+            end
+          when Module
+            dirs = nil
+            self.ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_directives) &&
+                  (anc_dirs = ancestor.own_directives).any?
+                dirs ||= []
+                merge_directives(dirs, anc_dirs)
+              end
+            end
+            if own_directives
+              dirs ||= []
+              merge_directives(dirs, own_directives)
+            end
+            dirs || NO_DIRECTIVES
+          when HasDirectives
+            @own_directives || NO_DIRECTIVES
+          else
+            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+          end
+        end
+
+        protected
+
+        def own_directives
+          @own_directives
+        end
+
+        private
+
+        # Modify `target` by adding items from `dirs` such that:
+        # - Any name conflict is overriden by the incoming member of `dirs`
+        # - Any other member of `dirs` is appended
+        # @param target [Array<GraphQL::Schema::Directive>]
+        # @param dirs [Array<GraphQL::Schema::Directive>]
+        # @return [void]
+        def merge_directives(target, dirs)
+          dirs.each do |dir|
+            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+              target.slice!(idx)
+              target.insert(idx, dir)
+            else
+              target << dir
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end