graphql 2.0.21 → 2.0.32

data/lib/graphql/schema/argument.rb

@@ -53,6 +53,7 @@ module GraphQL
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
+        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
         @null = required != true
@@ -88,11 +89,8 @@ module GraphQL
         end
 
         if definition_block
-          if definition_block.arity == 1
-            instance_exec(self, &definition_block)
-          else
-            instance_eval(&definition_block)
-          end
+          # `self` will still be self, it will also be the first argument to the block:
+          instance_exec(self, &definition_block)
         end
       end
 
@@ -198,8 +196,8 @@ module GraphQL
 
       def statically_coercible?
         return @statically_coercible if defined?(@statically_coercible)
-
-        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+        requires_parent_object = @prepare.is_a?(String) || @prepare.is_a?(Symbol) || @own_validators
+        @statically_coercible = !requires_parent_object
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
@@ -264,7 +262,7 @@ module GraphQL
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
-        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
+        argument_values[arg_key] = context.query.after_lazy(coerced_value) do |resolved_coerced_value|
           owner.validate_directive_argument(self, resolved_coerced_value)
           prepared_value = begin
             prepare_value(parent_object, resolved_coerced_value, context: context)
@@ -281,7 +279,7 @@ module GraphQL
           end
 
           maybe_loaded_value = loaded_value || prepared_value
-          context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+          context.query.after_lazy(maybe_loaded_value) do |resolved_loaded_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: resolved_loaded_value,
@@ -303,7 +301,7 @@ module GraphQL
           else
             load_method_owner.public_send(arg_load_method, coerced_value)
           end
-          context.schema.after_lazy(custom_loaded_value) do |custom_value|
+          context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
                 loaded_values = custom_value.each_with_index.map { |custom_val, idx|

data/lib/graphql/schema/build_from_definition.rb

@@ -453,17 +453,18 @@ module GraphQL
 
             # 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
-              RUBY
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
             end
           end
         end
 
+        def define_field_resolve_method(owner, method_name, field_name)
+          owner.define_method(method_name) { |**args|
+            field_instance = self.class.get_field(field_name)
+            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+          }
+        end
+
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
           resolve_type_proc = nil
           resolve_type_proc = ->(ast_node) {

data/lib/graphql/schema/directive.rb

@@ -99,7 +99,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @default_graphql_name ||= nil
           end
         end

data/lib/graphql/schema/enum_value.rb

@@ -34,7 +34,7 @@ module GraphQL
         @graphql_name = graphql_name.to_s
         GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
-        @value = value === NOT_CONFIGURED ? @graphql_name : value
+        @value = value == NOT_CONFIGURED ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
         end
@@ -47,7 +47,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_eval(&block)
+          instance_exec(self, &block)
         end
       end
 

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

@@ -26,7 +26,7 @@ module GraphQL
           # rename some inputs to avoid conflicts inside the block
           maybe_lazy = value
           value = nil
-          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+          context.query.after_lazy(maybe_lazy) do |resolved_value|
             value = resolved_value
             if value.is_a? GraphQL::ExecutionError
               # This isn't even going to work because context doesn't have ast_node anymore

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)
@@ -233,9 +233,9 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-
+        NameValidator.validate!(@name)
         @description = description
-        @type = @owner_type = @own_validators = @own_directives = @own_arguments = nil # these will be prepared later if necessary
+        @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
 
         self.deprecation_reason = deprecation_reason
 
@@ -339,7 +339,7 @@ module GraphQL
           self.validates(validates)
         end
 
-        if definition_block
+        if block_given?
           if definition_block.arity == 1
             yield self
           else
@@ -661,7 +661,7 @@ module GraphQL
 
         Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
-        query_ctx.schema.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
+        query_ctx.query.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
           if is_authorized
             with_extensions(object, args, query_ctx) do |obj, ruby_kwargs|
               method_args = ruby_kwargs
@@ -810,6 +810,17 @@ ERR
         end
       end
 
+      class ExtendedState
+        def initialize(args, object)
+          @arguments = args
+          @object = object
+          @memos = nil
+          @added_extras = nil
+        end
+
+        attr_accessor :arguments, :object, :memos, :added_extras
+      end
+
       # Wrap execution with hooks.
       # Written iteratively to avoid big stack traces.
       # @return [Object] Whatever the
@@ -820,20 +831,20 @@ ERR
           # 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, added_extras: nil }
+          extended = ExtendedState.new(args, obj)
           value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
-            if (added_extras = extended[:added_extras])
+            if (added_extras = extended.added_extras)
               args = args.dup
               added_extras.each { |e| args.delete(e) }
             end
             yield(obj, args)
           end
 
-          extended_obj = extended[:obj]
-          extended_args = extended[:args]
-          memos = extended[:memos] || EMPTY_HASH
+          extended_obj = extended.object
+          extended_args = extended.arguments # rubocop:disable Development/ContextIsPassedCop
+          memos = extended.memos || EMPTY_HASH
 
-          ctx.schema.after_lazy(value) do |resolved_value|
+          ctx.query.after_lazy(value) do |resolved_value|
             idx = 0
             @extensions.each do |ext|
               memo = memos[idx]
@@ -851,17 +862,17 @@ ERR
         if extension
           extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
             if memo
-              memos = extended[:memos] ||= {}
+              memos = extended.memos ||= {}
               memos[idx] = memo
             end
 
             if (extras = extension.added_extras)
-              ae = extended[:added_extras] ||= []
+              ae = extended.added_extras ||= []
               ae.concat(extras)
             end
 
-            extended[:obj] = extended_obj
-            extended[:args] = extended_args
+            extended.object = extended_obj
+            extended.arguments = extended_args
             run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }
           end
         else

data/lib/graphql/schema/input_object.rb

@@ -131,12 +131,7 @@ module GraphQL
             end
           end
           # Add a method access
-          method_name = argument_defn.keyword
-          class_eval <<-RUBY, __FILE__, __LINE__
-            def #{method_name}
-              self[#{method_name.inspect}]
-            end
-          RUBY
+          define_accessor_method(argument_defn.keyword)
           argument_defn
         end
 
@@ -211,7 +206,7 @@ module GraphQL
 
           arguments = coerce_arguments(nil, value, ctx)
 
-          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+          ctx.query.after_lazy(arguments) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::Error)
               raise resolved_arguments
             else
@@ -242,6 +237,13 @@ module GraphQL
 
           result
         end
+
+        private
+
+        def define_accessor_method(method_name)
+          define_method(method_name) { self[method_name] }
+          alias_method(method_name, method_name)
+        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -69,7 +69,11 @@ module GraphQL
             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/member/has_interfaces.rb") && line.include?("in `implements'")}
+            backtrace_line = caller_locations(0, 10).find do |location|
+              location.base_label == "implements" &&
+                location.path.end_with?("schema/member/has_interfaces.rb")
+            end
+
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end

data/lib/graphql/schema/introspection_system.rb

@@ -155,7 +155,7 @@ module GraphQL
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
-          wrapped_object = @object_class.authorized_new(obj, query_ctx)
+          wrapped_object = @object_class.wrap(obj, query_ctx)
           @inner_resolve.call(wrapped_object, args, ctx)
         end
       end

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

@@ -109,7 +109,14 @@ module GraphQL
               to_type_name(something.name)
             end
           when String
-            something.gsub(/\]\[\!/, "").split("::").last
+            if something.include?("]") ||
+                something.include?("[") ||
+                something.include?("!") ||
+                something.include?("::")
+              something.gsub(/\]\[\!/, "").split("::").last
+            else
+              something
+            end
           when GraphQL::Schema::NonNull, GraphQL::Schema::List
             to_type_name(something.unwrap)
           else
@@ -122,7 +129,8 @@ module GraphQL
           return string unless string.include?("_")
           camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
-          if (match_data = string.match(/\A(_+)/))
+          if string.start_with?("_")
+            match_data = string.match(/\A(_+)/)
             camelized = "#{match_data[0]}#{camelized}"
           end
           camelized

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

@@ -51,7 +51,7 @@ module GraphQL
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
                 argument = get_argument("#{arg_defn.graphql_name}")
-                (context || self.context).schema.after_lazy(values) do |values2|
+                (context || self.context).query.after_lazy(values) do |values2|
                   GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
                 end
               end
@@ -320,9 +320,11 @@ module GraphQL
         end
 
         def arguments_statically_coercible?
-          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
-
-          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          if defined?(@arguments_statically_coercible) && !@arguments_statically_coercible.nil?
+            @arguments_statically_coercible
+          else
+            @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+          end
         end
 
         module ArgumentClassAccessor
@@ -363,7 +365,7 @@ module GraphQL
           end
 
           def authorize_application_object(argument, id, context, loaded_application_object)
-            context.schema.after_lazy(loaded_application_object) do |application_object|
+            context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
                 err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
                 load_application_object_failed(err)
@@ -371,7 +373,7 @@ module GraphQL
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
               maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.schema.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
                 if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
                   application_object_type, application_object = resolve_type_result
                 else
@@ -386,7 +388,7 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  context.schema.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
                     if authed
                       application_object
                     else

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

@@ -6,7 +6,7 @@ module GraphQL
       module HasDirectives
         def self.extended(child_cls)
           super
-          child_cls.module_eval { self.own_directives = nil }
+          child_cls.module_exec { self.own_directives = nil }
         end
 
         def inherited(child_cls)

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

@@ -180,7 +180,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_fields ||= nil
             @field_class ||= nil
           end

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

@@ -119,7 +119,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_interface_type_memberships ||= nil
           end
         end

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

@@ -43,7 +43,7 @@ module GraphQL
         private
 
         def inherited(subclass)
-          subclass.class_eval do
+          subclass.class_exec do
             @to_non_null_type ||= nil
             @to_list_type ||= nil
           end

data/lib/graphql/schema/object.rb

@@ -30,6 +30,11 @@ module GraphQL
         # @see authorized_new to make instances
         protected :new
 
+        # This is called by the runtime to return an object to call methods on.
+        def wrap(object, context)
+          authorized_new(object, context)
+        end
+
         # Make a new instance of this type _if_ the auth check passes,
         # otherwise, raise an error.
         #
@@ -68,7 +73,7 @@ module GraphQL
             maybe_lazy_auth_val
           end
 
-          context.schema.after_lazy(auth_val) do |is_authorized|
+          context.query.after_lazy(auth_val) do |is_authorized|
             if is_authorized
               self.new(object, context)
             else

data/lib/graphql/schema/printer.rb

@@ -57,12 +57,14 @@ module GraphQL
         query_root = Class.new(GraphQL::Schema::Object) do
           graphql_name "Root"
           field :throwaway_field, String
+          def self.visible?(ctx)
+            false
+          end
         end
         schema = Class.new(GraphQL::Schema) { query(query_root) }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -60,7 +60,7 @@ module GraphQL
           super()
         end
 
-        context.schema.after_lazy(return_value) do |return_hash|
+        context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
           if return_hash.is_a?(Hash)
             return_hash[:client_mutation_id] = client_mutation_id

data/lib/graphql/schema/resolver.rb

@@ -65,41 +65,43 @@ 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.schema.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)
-            context.schema.after_lazy(load_arguments_val) do |loaded_args|
+            context.query.after_lazy(load_arguments_val) do |loaded_args|
               @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.schema.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)
@@ -185,7 +187,7 @@ module GraphQL
           if arg_defn
             prepped_value = prepared_args[key] = arg_defn.load_and_authorize_value(self, value, context)
             if context.schema.lazy?(prepped_value)
-              prepare_lazies << context.schema.after_lazy(prepped_value) do |finished_prepped_value|
+              prepare_lazies << context.query.after_lazy(prepped_value) do |finished_prepped_value|
                 prepared_args[key] = finished_prepped_value
               end
             end

data/lib/graphql/schema/timeout.rb

@@ -90,7 +90,7 @@ module GraphQL
       # The default implementation returns the `max_seconds:` value from installing this plugin.
       #
       # @param query [GraphQL::Query] The query that's about to run
-      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      # @return [Numeric, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
       def max_seconds(query)
         @max_seconds
       end

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/schema/warden.rb

@@ -38,8 +38,9 @@ module GraphQL
     # @api private
     class Warden
       def self.from_context(context)
-        context.warden # this might be a hash which won't respond to this
-      rescue
+        context.warden || PassThruWarden
+      rescue NoMethodError
+        # this might be a hash which won't respond to #warden
         PassThruWarden
       end
 
@@ -87,17 +88,49 @@ module GraphQL
         end
       end
 
+      class NullWarden
+        def initialize(_filter = nil, context:, schema:)
+          @schema = schema
+        end
+
+        def visible_field?(field_defn, _ctx = nil, owner = nil); true; end
+        def visible_argument?(arg_defn, _ctx = nil); true; end
+        def visible_type?(type_defn, _ctx = nil); true; end
+        def visible_enum_value?(enum_value, _ctx = nil); true; end
+        def visible_type_membership?(type_membership, _ctx = nil); true; end
+        def interface_type_memberships(obj_type, _ctx = nil); obj_type.interface_type_memberships; end
+        def get_type(type_name); @schema.get_type(type_name); end # rubocop:disable Development/ContextIsPassedCop
+        def arguments(argument_owner, ctx = nil); argument_owner.all_argument_definitions; end
+        def enum_values(enum_defn); enum_defn.enum_values; end # rubocop:disable Development/ContextIsPassedCop
+        def get_argument(parent_type, argument_name); parent_type.get_argument(argument_name); end # rubocop:disable Development/ContextIsPassedCop
+        def types; @schema.types; end # rubocop:disable Development/ContextIsPassedCop
+        def root_type_for_operation(op_name); @schema.root_type_for_operation(op_name); end
+        def directives; @schema.directives.values; end
+        def fields(type_defn); type_defn.all_field_definitions; end # rubocop:disable Development/ContextIsPassedCop
+        def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
+        def reachable_type?(type_name); true; end
+        def reachable_types; @schema.types.values; end # rubocop:disable Development/ContextIsPassedCop
+        def possible_types(type_defn); @schema.possible_types(type_defn); end
+        def interfaces(obj_type); obj_type.interfaces; end
+      end
+
       # @param filter [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
-      def initialize(filter, context:, schema:)
+      def initialize(filter = nil, context:, schema:)
         @schema = schema
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
         @query = @schema.query
         @mutation = @schema.mutation
         @subscription = @schema.subscription
         @context = context
-        @visibility_cache = read_through { |m| filter.call(m, context) }
+        @visibility_cache = if filter
+          read_through { |m| filter.call(m, context) }
+        else
+          read_through { |m| schema.visible?(m, context) }
+        end
+
+        @visibility_cache.compare_by_identity
         # Initialize all ivars to improve object shape consistency:
         @types = @visible_types = @reachable_types = @visible_parent_fields =
           @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =