graphql 2.4.3 → 2.5.0

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, comment: 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
         @comment = comment
@@ -89,11 +90,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
 
@@ -219,7 +217,7 @@ module GraphQL
       # @api private
       def prepare_value(obj, value, context: nil)
         if type.unwrap.kind.input_object?
-          value = recursively_prepare_input_object(value, type)
+          value = recursively_prepare_input_object(value, type, context)
         end
 
         Schema::Validator.validate!(validators, obj, context, value)
@@ -400,15 +398,16 @@ module GraphQL
 
       private
 
-      def recursively_prepare_input_object(value, type)
+      def recursively_prepare_input_object(value, type, context)
         if type.non_null?
           type = type.of_type
         end
 
         if type.list? && !value.nil?
           inner_type = type.of_type
-          value.map { |v| recursively_prepare_input_object(v, inner_type) }
+          value.map { |v| recursively_prepare_input_object(v, inner_type, context) }
         elsif value.is_a?(GraphQL::Schema::InputObject)
+          value.validate_for(context)
           value.prepare
         else
           value

data/lib/graphql/schema/build_from_definition.rb

@@ -20,8 +20,8 @@ module GraphQL
           from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
-          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using, base_types: base_types)
         end
       end
 
@@ -30,9 +30,18 @@ module GraphQL
         include GraphQL::EmptyObjects
         extend self
 
-        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
+          base_types = {
+            object: GraphQL::Schema::Object,
+            interface: GraphQL::Schema::Interface,
+            union: GraphQL::Schema::Union,
+            scalar: GraphQL::Schema::Scalar,
+            enum: GraphQL::Schema::Enum,
+            input_object: GraphQL::Schema::InputObject,
+          }.merge!(base_types)
+
           if default_resolve.is_a?(Hash)
             default_resolve = ResolveMap.new(default_resolve)
           end
@@ -53,7 +62,7 @@ module GraphQL
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
               if defn
-                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+                build_definition_from_node(defn, directive_type_resolver, default_resolve, base_types)
               elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
                 built_in_defn
               else
@@ -77,14 +86,20 @@ module GraphQL
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
-            when GraphQL::Language::Nodes::SchemaExtension
+            when GraphQL::Language::Nodes::SchemaExtension,
+              GraphQL::Language::Nodes::ScalarTypeExtension,
+              GraphQL::Language::Nodes::ObjectTypeExtension,
+              GraphQL::Language::Nodes::InterfaceTypeExtension,
+              GraphQL::Language::Nodes::UnionTypeExtension,
+              GraphQL::Language::Nodes::EnumTypeExtension,
+              GraphQL::Language::Nodes::InputObjectTypeExtension
               schema_extensions ||= []
               schema_extensions << definition
             else
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
-                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve)
+                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
           end
@@ -124,6 +139,34 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
+          schema_extensions&.each do |ext|
+            next if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
+
+            built_type = types[ext.name]
+
+            case ext
+            when GraphQL::Language::Nodes::ScalarTypeExtension
+              build_directives(built_type, ext, type_resolver)
+            when GraphQL::Language::Nodes::ObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: true)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::InterfaceTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: nil)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::UnionTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              built_type.possible_types(*ext.types.map { |type_name| type_resolver.call(type_name) })
+            when GraphQL::Language::Nodes::EnumTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_values(built_type, ext.values, type_resolver)
+            when GraphQL::Language::Nodes::InputObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_arguments(built_type, ext.fields, type_resolver)
+            end
+          end
+
           builder = self
 
           found_types = types.values
@@ -192,8 +235,8 @@ module GraphQL
             end
           end
 
-          if schema_extensions
-            schema_extensions.each do |ext|
+          schema_extensions&.each do |ext|
+            if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
               build_directives(schema_class, ext, type_resolver)
             end
           end
@@ -205,20 +248,20 @@ module GraphQL
           raise(GraphQL::RequiredImplementationMissingError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
-        def build_definition_from_node(definition, type_resolver, default_resolve)
+        def build_definition_from_node(definition, type_resolver, default_resolve, base_types)
           case definition
           when GraphQL::Language::Nodes::EnumTypeDefinition
-            build_enum_type(definition, type_resolver)
+            build_enum_type(definition, type_resolver, base_types[:enum])
           when GraphQL::Language::Nodes::ObjectTypeDefinition
-            build_object_type(definition, type_resolver)
+            build_object_type(definition, type_resolver, base_types[:object])
           when GraphQL::Language::Nodes::InterfaceTypeDefinition
-            build_interface_type(definition, type_resolver)
+            build_interface_type(definition, type_resolver, base_types[:interface])
           when GraphQL::Language::Nodes::UnionTypeDefinition
-            build_union_type(definition, type_resolver)
+            build_union_type(definition, type_resolver, base_types[:union])
           when GraphQL::Language::Nodes::ScalarTypeDefinition
-            build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
+            build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
-            build_input_object_type(definition, type_resolver)
+            build_input_object_type(definition, type_resolver, base_types[:input_object])
           end
         end
 
@@ -284,22 +327,26 @@ module GraphQL
           end
         end
 
-        def build_enum_type(enum_type_definition, type_resolver)
+        def build_enum_type(enum_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Enum) do
+          Class.new(base_type) do
             graphql_name(enum_type_definition.name)
             builder.build_directives(self, enum_type_definition, type_resolver)
             description(enum_type_definition.description)
             ast_node(enum_type_definition)
-            enum_type_definition.values.each do |enum_value_definition|
-              value(enum_value_definition.name,
-                value: enum_value_definition.name,
-                deprecation_reason: builder.build_deprecation_reason(enum_value_definition.directives),
-                description: enum_value_definition.description,
-                directives: builder.prepare_directives(enum_value_definition, type_resolver),
-                ast_node: enum_value_definition,
-              )
-            end
+            builder.build_values(self, enum_type_definition.values, type_resolver)
+          end
+        end
+
+        def build_values(type_class, enum_value_definitions, type_resolver)
+          enum_value_definitions.each do |enum_value_definition|
+            type_class.value(enum_value_definition.name,
+              value: enum_value_definition.name,
+              deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
+              description: enum_value_definition.description,
+              directives: prepare_directives(enum_value_definition, type_resolver),
+              ast_node: enum_value_definition,
+            )
           end
         end
 
@@ -313,9 +360,9 @@ module GraphQL
           reason.value
         end
 
-        def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+        def build_scalar_type(scalar_type_definition, type_resolver, base_type, default_resolve:)
           builder = self
-          Class.new(GraphQL::Schema::Scalar) do
+          Class.new(base_type) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
@@ -336,9 +383,9 @@ module GraphQL
           end
         end
 
-        def build_union_type(union_type_definition, type_resolver)
+        def build_union_type(union_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Union) do
+          Class.new(base_type) do
             graphql_name(union_type_definition.name)
             description(union_type_definition.description)
             possible_types(*union_type_definition.types.map { |type_name| type_resolver.call(type_name) })
@@ -347,27 +394,28 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver)
+        def build_object_type(object_type_definition, type_resolver, base_type)
           builder = self
 
-          Class.new(GraphQL::Schema::Object) do
+          Class.new(base_type) do
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
             builder.build_directives(self, object_type_definition, type_resolver)
-
-            object_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
-
+            builder.build_interfaces(self, object_type_definition.interfaces, type_resolver)
             builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
-        def build_input_object_type(input_object_type_definition, type_resolver)
+        def build_interfaces(type_class, interface_names, type_resolver)
+          interface_names.each do |interface_name|
+            type_class.implements(type_resolver.call(interface_name))
+          end
+        end
+
+        def build_input_object_type(input_object_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::InputObject) do
+          Class.new(base_type) do
             graphql_name(input_object_type_definition.name)
             description(input_object_type_definition.description)
             ast_node(input_object_type_definition)
@@ -427,16 +475,13 @@ module GraphQL
           end
         end
 
-        def build_interface_type(interface_type_definition, type_resolver)
+        def build_interface_type(interface_type_definition, type_resolver, base_type)
           builder = self
           Module.new do
-            include GraphQL::Schema::Interface
+            include base_type
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
-            interface_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
+            builder.build_interfaces(self, interface_type_definition.interfaces, type_resolver)
             ast_node(interface_type_definition)
             builder.build_directives(self, interface_type_definition, type_resolver)
 
@@ -467,17 +512,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/flagged.rb

@@ -45,7 +45,7 @@ module GraphQL
           def visible?(context)
             if dir = self.directives.find { |d| d.is_a?(Flagged) }
               relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f # rubocop:disable Development/ContextIsPassedCop -- definition-related
-              relevant_flags && relevant_flags.any? && super
+              relevant_flags && !relevant_flags.empty? && super
             else
               super
             end

data/lib/graphql/schema/directive.rb

@@ -29,7 +29,7 @@ module GraphQL
         end
 
         def locations(*new_locations)
-          if new_locations.any?
+          if !new_locations.empty?
             new_locations.each do |new_loc|
               if !LOCATIONS.include?(new_loc.to_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
@@ -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.rb

@@ -61,12 +61,19 @@ module GraphQL
         # @option kwargs [String] :description, the GraphQL description for this value, present in documentation
         # @option kwargs [String] :comment, the GraphQL comment for this value, present in documentation
         # @option kwargs [::Object] :value the translated Ruby value for this object (defaults to `graphql_name`)
+        # @option kwargs [::Object] :value_method, the method name to fetch `graphql_name` (defaults to `graphql_name.downcase`)
         # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
+        # @param value_method [Symbol, false] A method to generate for this value, or `false` to skip generation
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
-        def value(*args, **kwargs, &block)
+        def value(*args, value_method: nil, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
+
+          if value_method || (value_methods && value_method != false)
+            generate_value_method(value, value_method)
+          end
+
           key = value.graphql_name
           prev_value = own_values[key]
           case prev_value
@@ -154,6 +161,18 @@ module GraphQL
           end
         end
 
+        def value_methods(new_value = NOT_CONFIGURED)
+          if NOT_CONFIGURED.equal?(new_value)
+            if @value_methods != nil
+              @value_methods
+            else
+              find_inherited_value(:value_methods, false)
+            end
+          else
+            @value_methods = new_value
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::ENUM
         end
@@ -215,6 +234,7 @@ module GraphQL
             # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
             child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
           end
+          child_class.class_exec { @value_methods = nil }
           super
         end
 
@@ -223,6 +243,21 @@ module GraphQL
         def own_values
           @own_values ||= {}
         end
+
+        def generate_value_method(value, configured_value_method)
+          return if configured_value_method == false
+
+          value_method_name = configured_value_method || value.graphql_name.downcase
+
+          if respond_to?(value_method_name.to_sym)
+            warn "Failed to define value method for :#{value_method_name}, because " \
+              "#{value.owner.name || value.owner.graphql_name} already responds to that method. Use `value_method:` to override the method name " \
+              "or `value_method: false` to disable Enum value method generation."
+            return
+          end
+
+          define_singleton_method(value_method_name) { value.graphql_name }
+        end
       end
 
       enum_value_class(GraphQL::Schema::EnumValue)

data/lib/graphql/schema/enum_value.rb

@@ -48,7 +48,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_eval(&block)
+          instance_exec(self, &block)
         end
       end
 

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

@@ -12,7 +12,7 @@ module GraphQL
             if ret_type.respond_to?(:scope_items)
               scoped_items = ret_type.scope_items(value, context)
               if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
-                if (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+                if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
                     (query_runtime_state = current_runtime_state[context.query])
                   query_runtime_state.was_authorized_by_scope_items = true
                 end

data/lib/graphql/schema/field.rb

@@ -42,8 +42,8 @@ module GraphQL
       end
 
       def directives
-        if @resolver_class && (r_dirs = @resolver_class.directives).any?
-          if (own_dirs = super).any?
+        if @resolver_class && !(r_dirs = @resolver_class.directives).empty?
+          if !(own_dirs = super).empty?
             own_dirs + r_dirs
           else
             r_dirs
@@ -81,7 +81,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path}#{all_argument_definitions.any? ? "(...)" : ""}: #{type.to_type_signature}>"
+        "#<#{self.class} #{path}#{!all_argument_definitions.empty? ? "(...)" : ""}: #{type.to_type_signature}>"
       end
 
       alias :mutation :resolver
@@ -255,7 +255,7 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-
+        NameValidator.validate!(@name)
         @description = description
         @comment = comment
         @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
@@ -335,15 +335,15 @@ module GraphQL
         @call_after_define = false
         set_pagination_extensions(connection_extension: connection_extension)
         # Do this last so we have as much context as possible when initializing them:
-        if extensions.any?
+        if !extensions.empty?
           self.extensions(extensions)
         end
 
-        if resolver_class && resolver_class.extensions.any?
+        if resolver_class && !resolver_class.extensions.empty?
           self.extensions(resolver_class.extensions)
         end
 
-        if directives.any?
+        if !directives.empty?
           directives.each do |(dir_class, options)|
             self.directive(dir_class, **options)
           end
@@ -369,7 +369,7 @@ module GraphQL
           if @definition_block.arity == 1
             @definition_block.call(self)
           else
-            instance_eval(&@definition_block)
+            instance_exec(self, &@definition_block)
           end
           self.extensions.each(&:after_define_apply)
           @call_after_define = true
@@ -482,7 +482,7 @@ module GraphQL
         if new_extras.nil?
           # Read the value
           field_extras = @extras
-          if @resolver_class && @resolver_class.extras.any?
+          if @resolver_class && !@resolver_class.extras.empty?
             field_extras + @resolver_class.extras
           else
             field_extras
@@ -732,7 +732,7 @@ module GraphQL
                 method_to_call = resolver_method
                 method_receiver = obj
                 # Call the method with kwargs, if there are any
-                if ruby_kwargs.any?
+                if !ruby_kwargs.empty?
                   obj.public_send(resolver_method, **ruby_kwargs)
                 else
                   obj.public_send(resolver_method)
@@ -752,7 +752,7 @@ module GraphQL
               elsif inner_object.respond_to?(@method_sym)
                 method_to_call = @method_sym
                 method_receiver = obj.object
-                if ruby_kwargs.any?
+                if !ruby_kwargs.empty?
                   inner_object.public_send(@method_sym, **ruby_kwargs)
                 else
                   inner_object.public_send(@method_sym)
@@ -839,7 +839,7 @@ module GraphQL
           unsatisfied_ruby_kwargs.clear
         end
 
-        if unsatisfied_ruby_kwargs.any? || unsatisfied_method_params.any?
+        if !unsatisfied_ruby_kwargs.empty? || !unsatisfied_method_params.empty?
           raise FieldImplementationFailed.new, <<-ERR
 Failed to call `#{method_name.inspect}` on #{receiver.inspect} because the Ruby method params were incompatible with the GraphQL arguments:
 

data/lib/graphql/schema/field_extension.rb

@@ -104,7 +104,7 @@ module GraphQL
             end
           end
         end
-        if (extras = self.class.extras).any?
+        if !(extras = self.class.extras).empty?
           @added_extras = extras - field.extras
           field.extras(@added_extras)
         else

data/lib/graphql/schema/has_single_input_argument.rb

@@ -32,7 +32,7 @@ module GraphQL
           input_kwargs = {}
         end
 
-        if input_kwargs.any?
+        if !input_kwargs.empty?
           super(**input_kwargs)
         else
           super()
@@ -136,6 +136,8 @@ module GraphQL
                 super || "Autogenerated input type of #{self.mutation.graphql_name}"
               end
             end
+            # For compatibility, in case no arguments are defined:
+            has_no_arguments(true)
             mutation(mutation_class)
             # these might be inherited:
             mutation_args.each do |arg|