graphql 2.0.23 → 2.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aade8e5f88eb3dd8e8d6148aa7e8e00b0a351422b090e02a911158f425f1905
-  data.tar.gz: 1ee1e4529f0b1f68596ce73f2b171624637999f0a1d6fc03f377c46fc7756a78
+  metadata.gz: 7c97d63232efb5f7ecdaef0f8102a73ceaa4a4b0a3b06c7ab1f613735efafa59
+  data.tar.gz: aff3df56a3db15d97f457e92fffab33f29440fed5ca84b0515794ad051e5631e
 SHA512:
-  metadata.gz: 8b9cd861e35c529674bdacb6e1a34864bca6852c030022215ecc028d2b36b20da120be4ee45bb5ac5fb906b856e78dc4cfbbcf55609ad47fc47e6d68422a26b1
-  data.tar.gz: b4afc463a0c9058396f274c9224f5a6b0bca73fefc68c1e6f10e53eea24b95b89ef6d9ddd3e22929d90be69b7c46bd81e6ed134ddab2550cbfc4408aee29b8ef
+  metadata.gz: 3cf33d0ed4df848c57e459f9ee023b0a6b2814d14ef09d7c304120a595cd62e65f25b05b3f16448c89cfb9479d06e550611c42fa76b3fb92a677c788f31f713e
+  data.tar.gz: 28b8d5e3fb2d6cc0bc3ebbdaf6f6d53dc16b0225bcafcc0fe72d4956afb9ff0fdb1ca929093ad466951dc28a30d893e643c8fb68bff69df374e41e1c43e2980b

data/lib/graphql/dataloader/source.rb

@@ -39,7 +39,7 @@ module GraphQL
           result_for(key)
         else
           @pending_keys << key
-          sync
+          sync([key])
           result_for(key)
         end
       end
@@ -50,7 +50,7 @@ module GraphQL
         if keys.any? { |k| !@results.key?(k) }
           pending_keys = keys.select { |k| !@results.key?(k) }
           @pending_keys.concat(pending_keys)
-          sync
+          sync(pending_keys)
         end
 
         keys.map { |k| result_for(k) }
@@ -67,8 +67,7 @@ module GraphQL
       # Wait for a batch, if there's anything to batch.
       # Then run the batch and update the cache.
       # @return [void]
-      def sync
-        pending_keys = @pending_keys.dup
+      def sync(pending_keys)
         @dataloader.yield
         iterations = 0
         while pending_keys.any? { |k| !@results.key?(k) }

data/lib/graphql/execution/interpreter/runtime.rb

@@ -247,15 +247,15 @@ module GraphQL
           st = get_current_runtime_state
           st.current_object = query.root_value
           st.current_result = @response
-          object_proxy = authorized_new(root_type, query.root_value, context)
-          object_proxy = schema.sync_lazy(object_proxy)
+          runtime_object = root_type.wrap(query.root_value, context)
+          runtime_object = schema.sync_lazy(runtime_object)
 
-          if object_proxy.nil?
+          if runtime_object.nil?
             # Root .authorized? returned false.
             @response = nil
           else
-            call_method_on_directives(:resolve, object_proxy, root_operation.directives) do # execute query level directives
-              gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
+            call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
+              gathered_selections = gather_selections(runtime_object, root_type, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
               # make a new, isolated result hash for writing the result into. (That isolated response
@@ -280,9 +280,9 @@ module GraphQL
                   if (directives = selections[:graphql_directives])
                     selections.delete(:graphql_directives)
                   end
-                  call_method_on_directives(:resolve, object_proxy, directives) do
+                  call_method_on_directives(:resolve, runtime_object, directives) do
                     evaluate_selections(
-                      object_proxy,
+                      runtime_object,
                       root_type,
                       root_op_type == "mutation",
                       selections,
@@ -438,10 +438,8 @@ module GraphQL
           st.current_result = selections_result
           st.current_result_name = result_name
 
-          object = owner_object
-
           if is_introspection
-            object = authorized_new(field_defn.owner, object, context)
+            owner_object = field_defn.owner.wrap(owner_object, context)
           end
 
           total_args_count = field_defn.arguments(context).size
@@ -449,14 +447,14 @@ module GraphQL
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
             end
           else
-            @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+            @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
             end
           end
         end
@@ -774,7 +772,7 @@ module GraphQL
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(current_type, value, context)
+              current_type.wrap(value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
@@ -1047,10 +1045,6 @@ module GraphQL
           end
         end
 
-        def authorized_new(type, value, context)
-          type.authorized_new(value, context)
-        end
-
         def lazy?(object)
           obj_class = object.class
           is_lazy = @lazy_cache[obj_class]

data/lib/graphql/introspection/entry_points.rb

@@ -11,7 +11,7 @@ module GraphQL
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.authorized_new(schema, @context)
+        schema_type.wrap(schema, @context)
       end
 
       def __type(name:)

data/lib/graphql/query/validation_pipeline.rb

@@ -68,7 +68,8 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          validator = @query.static_validator || @schema.static_validator
+          validation_result = validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
 
           if @validation_errors.empty?

data/lib/graphql/query.rb

@@ -45,6 +45,20 @@ module GraphQL
       end
     end
 
+    # @return [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules.
+    attr_reader :static_validator
+
+    # @param new_validate [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules. This can't be reasssigned after validation.
+    def static_validator=(new_validator)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#static_validator= after validation has run, remove this assignment."
+      elsif !new_validator.is_a?(GraphQL::StaticValidation::Validator)
+        raise ArgumentError, "Expected a `GraphQL::StaticValidation::Validator` instance."
+      else
+        @static_validator = new_validator
+      end
+    end
+
     attr_writer :query_string
 
     # @return [GraphQL::Language::Nodes::Document]
@@ -83,7 +97,7 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
@@ -97,6 +111,7 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
+      self.static_validator = static_validator if static_validator
       context_tracers = (context ? context.fetch(:tracers, []) : [])
       @tracers = schema.tracers + context_tracers
 

data/lib/graphql/schema/addition.rb

@@ -40,14 +40,21 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        dirs = owner.directives.map(&:class)
-        @directives.merge(dirs)
-        add_type_and_traverse(dirs)
+        if (dir_instances = owner.directives).any?
+          dirs = dir_instances.map(&:class)
+          @directives.merge(dirs)
+          add_type_and_traverse(dirs)
+        end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        path = []
+        new_types.each do |t|
+          path.push(t.graphql_name)
+          add_type(t, owner: nil, late_types: late_types, path: path)
+          path.pop
+        end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
           type_owner, lt = late_type_vals
@@ -158,7 +165,9 @@ module GraphQL
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
             references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+            path.push(arg.graphql_name)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path)
+            path.pop
             if arg.default_value?
               @arguments_with_default_values << arg
             end
@@ -179,18 +188,21 @@ module GraphQL
               name = field.graphql_name
               field_type = field.type.unwrap
               references_to(field_type, from: field)
-              field_path = path + [name]
-              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              path.push(name)
+              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg.graphql_name])
+                path.push(arg.graphql_name)
+                add_type(arg_type, owner: arg, late_types: late_types, path: path)
+                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
+              path.pop
             end
           end
           if type.kind.input_object?
@@ -198,7 +210,9 @@ module GraphQL
               add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+              path.push(arg.graphql_name)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path)
+              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
@@ -206,14 +220,18 @@ module GraphQL
           end
           if type.kind.union?
             @possible_types[type.graphql_name] = type.all_possible_types
+            path.push("possible_types")
             type.all_possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.interface?
+            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.object?
             possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
@@ -221,6 +239,7 @@ module GraphQL
           end
 
           if type.kind.object? || type.kind.interface?
+            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
@@ -235,8 +254,9 @@ module GraphQL
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+              add_type(interface_type, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
         end
       end

data/lib/graphql/schema/field.rb

@@ -339,7 +339,7 @@ module GraphQL
           self.validates(validates)
         end
 
-        if definition_block
+        if block_given?
           if definition_block.arity == 1
             yield self
           else

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/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.
         #

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.23
+  version: 2.0.24
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -623,7 +623,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby