graphql 1.11.10 → 1.11.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edd6b4edae07b6c52383810319efb2cdd19a8f818639dda22c79308620330274
-  data.tar.gz: '09869b52706e249e6e41282e9e06243547db556d42410c4e2d0cb9abf00d7e3f'
+  metadata.gz: 6d5cb52d52c7bff9e3ec317756e7f2d171fac202208ca3bfe4bce711b4f3216b
+  data.tar.gz: 0d087f84cd41caaea9e8953b78b4bef69349209a8e62321bb604cc68f5a3765d
 SHA512:
-  metadata.gz: d5c8e1b96dea2f3ac9c8c93639e6b0c9763984c9af6ca09201ef89bfbbfd2ff61cd622417d04f5624fb6c679822d8a58c1a148c5139e1e1e51bf03eb5aaaaa4a
-  data.tar.gz: 07c12d4dd5b50d5b36a3c8e298ae663969e203ce6103c449ec0b599c5960c145b34dd9c023986c5d3cb2f0d6169b5395530bca6d07985152fb12505dc1af6036
+  metadata.gz: 68ae0b7fec852524c7527b3222a06c217dd03723120204baed3a6bc67b87e5e629010b2b393c9e4c2c0747e10655f17d1cc06196ac6864bf899569039d9d3b21
+  data.tar.gz: 56ed8bd3fb0b5e3c27cee6180a91b9b8ece3364a7682a90e2a4e4604663e2744d30d46ac85988394b00f41c2341b4c761c09c83d21925e08e1223a91fdba333f

data/lib/graphql/language/nodes.rb

@@ -133,6 +133,8 @@ module GraphQL
         end
 
         class << self
+          # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
           # Add a default `#visit_method` and `#children_method_name` using the class name
           def inherited(child_class)
             super
@@ -265,8 +267,11 @@ module GraphQL
                   #{assignments.join("\n")}
                 end
               RUBY
+
+              # rubocop:enable Development/NoEvalCop
             end
           end
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

data/lib/graphql/language/visitor.rb

@@ -73,6 +73,7 @@ module GraphQL
           @document
         end
       end
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
 
       # Call the user-defined handler for `node`.
       def visit_node(node, parent)

data/lib/graphql/query/validation_pipeline.rb

@@ -72,7 +72,7 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 

data/lib/graphql/schema/argument.rb

@@ -49,6 +49,7 @@ module GraphQL
       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)
+        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
         @null = !required
@@ -64,11 +65,8 @@ module GraphQL
         self.deprecation_reason = deprecation_reason
 
         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
 

data/lib/graphql/schema/build_from_definition.rb

@@ -342,13 +342,7 @@ 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
@@ -367,6 +361,13 @@ module GraphQL
           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 resolve_type_name(type)
           case type
           when GraphQL::Language::Nodes::TypeName

data/lib/graphql/schema/enum_value.rb

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

data/lib/graphql/schema/field.rb

@@ -222,6 +222,7 @@ module GraphQL
         name_s = -name.to_s
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
+        NameValidator.validate!(@name)
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
           raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."

data/lib/graphql/schema/input_object.rb

@@ -125,12 +125,8 @@ module GraphQL
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           # 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
 
         def to_graphql
@@ -239,6 +235,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
     end
   end

data/lib/graphql/schema.rb

@@ -157,7 +157,7 @@ module GraphQL
 
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -196,7 +196,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -366,7 +366,7 @@ module GraphQL
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
       validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
+      res = validator.validate(query, timeout: validate_timeout)
       res[:errors]
     end
 
@@ -951,7 +951,6 @@ module GraphQL
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
         schema_defn.validate_timeout = validate_timeout
-        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -1120,15 +1119,14 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = if stored_possible_types && type.kind.interface?
-              stored_possible_types.select do |possible_type|
-                # Use `.graphql_name` comparison to match legacy vs class-based types.
-                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-              end
-            else
-              stored_possible_types
-            end
+            visible_possible_types = stored_possible_types.select do |possible_type|
+              next true unless type.kind.interface?
+              next true unless possible_type.kind.object?
+
+              # Use `.graphql_name` comparison to match legacy vs class-based types.
+              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+            end if stored_possible_types
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1287,19 +1285,6 @@ module GraphQL
         end
       end
 
-      attr_writer :validate_max_errors
-
-      def validate_max_errors(new_validate_max_errors = nil)
-        if new_validate_max_errors
-          @validate_max_errors = new_validate_max_errors
-        elsif defined?(@validate_max_errors)
-          @validate_max_errors
-        else
-          find_inherited_value(:validate_max_errors)
-        end
-      end
-
-
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)

data/lib/graphql/static_validation/base_visitor.rb

@@ -205,9 +205,6 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
-        if @context.too_many_errors?
-          throw :too_many_validation_errors
-        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -193,26 +193,26 @@ module GraphQL
           if node1.name != node2.name
             errored_nodes = [node1.name, node2.name].sort.join(" or ")
             msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: errored_nodes
-            ))
+            )
           end
 
           if !same_arguments?(node1, node2)
             args = [serialize_field_args(node1), serialize_field_args(node2)]
             conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
             msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
-            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: conflicts
-            ))
+            )
           end
         end
 

data/lib/graphql/static_validation/rules/fragments_are_finite.rb

@@ -7,12 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
               "Fragment #{defn.name} contains an infinite loop",
               nodes: defn.node,
               path: defn.path,
               name: defn.name
-            ))
+            )
           end
         end
       end

data/lib/graphql/static_validation/validation_context.rb

@@ -19,11 +19,10 @@ module GraphQL
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query, visitor_class, max_errors)
+      def initialize(query, visitor_class)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
-        @max_errors = max_errors || Float::INFINITY
         @on_dependency_resolve_handlers = []
         @visitor = visitor_class.new(document, self)
       end
@@ -39,10 +38,6 @@ module GraphQL
       def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
-
-      def too_many_errors?
-        @errors.length >= @max_errors
-      end
     end
   end
 end

data/lib/graphql/static_validation/validator.rb

@@ -22,9 +22,8 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @param validate [Boolean]
       # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
-      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query, validate: true, timeout: nil, max_errors: nil)
+      def validate(query, validate: true, timeout: nil)
         query.trace("validate", { validate: validate, query: query }) do
           can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
@@ -33,26 +32,23 @@ module GraphQL
             rules_to_use = validate ? @rules : []
             visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
             begin
               # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
-
-                catch(:too_many_validation_errors) do
-                  # Attach legacy-style rules.
-                  # Only loop through rules if it has legacy-style rules
-                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                    legacy_rules.each do |rule_class_or_module|
-                      if rule_class_or_module.method_defined?(:validate)
-                        rule_class_or_module.new.validate(context)
-                      end
+                # Attach legacy-style rules.
+                # Only loop through rules if it has legacy-style rules
+                unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+                  legacy_rules.each do |rule_class_or_module|
+                    if rule_class_or_module.method_defined?(:validate)
+                      rule_class_or_module.new.validate(context)
                     end
                   end
-
-                  context.visitor.visit
                 end
+
+                context.visitor.visit
               end
             rescue Timeout::Error
               handle_timeout(query, context)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.11.10"
+  VERSION = "1.11.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.11.10
+  version: 1.11.11
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-05 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -741,7 +741,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -756,8 +756,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []