graphql 2.4.13 → 2.5.11

data/lib/graphql/schema/ractor_shareable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module RactorShareable
+      def self.extended(schema_class)
+        schema_class.extend(SchemaExtension)
+        schema_class.freeze_schema
+      end
+
+      module SchemaExtension
+
+        def freeze_error_handlers(handlers)
+          handlers[:subclass_handlers].default_proc = nil
+          handlers[:subclass_handlers].each do |_class, subclass_handlers|
+            freeze_error_handlers(subclass_handlers)
+          end
+          Ractor.make_shareable(handlers)
+        end
+
+        def freeze_schema
+          # warm some ivars:
+          default_analysis_engine
+          default_execution_strategy
+          GraphQL.default_parser
+          default_logger
+          freeze_error_handlers(error_handlers)
+          # TODO: this freezes errors of parent classes which could cause trouble
+          parent_class = superclass
+          while parent_class.respond_to?(:error_handlers)
+            freeze_error_handlers(parent_class.error_handlers)
+            parent_class = parent_class.superclass
+          end
+
+          own_tracers.freeze
+          @frozen_tracers = tracers.freeze
+          own_trace_modes.each do |m|
+            trace_options_for(m)
+            build_trace_mode(m)
+          end
+          build_trace_mode(:default)
+          Ractor.make_shareable(@trace_options_for_mode)
+          Ractor.make_shareable(own_trace_modes)
+          Ractor.make_shareable(own_multiplex_analyzers)
+          @frozen_multiplex_analyzers = Ractor.make_shareable(multiplex_analyzers)
+          Ractor.make_shareable(own_query_analyzers)
+          @frozen_query_analyzers = Ractor.make_shareable(query_analyzers)
+          Ractor.make_shareable(own_plugins)
+          own_plugins.each do |(plugin, options)|
+            Ractor.make_shareable(plugin)
+            Ractor.make_shareable(options)
+          end
+          @frozen_plugins = Ractor.make_shareable(plugins)
+          Ractor.make_shareable(own_references_to)
+          @frozen_directives = Ractor.make_shareable(directives)
+
+          Ractor.make_shareable(visibility)
+          Ractor.make_shareable(introspection_system)
+          extend(FrozenMethods)
+
+          Ractor.make_shareable(self)
+          superclass.respond_to?(:freeze_schema) && superclass.freeze_schema
+        end
+
+        module FrozenMethods
+          def tracers; @frozen_tracers; end
+          def multiplex_analyzers; @frozen_multiplex_analyzers; end
+          def query_analyzers; @frozen_query_analyzers; end
+          def plugins; @frozen_plugins; end
+          def directives; @frozen_directives; end
+
+          # This actually accumulates info during execution...
+          # How to support it?
+          def lazy?(_obj); false; end
+          def sync_lazy(obj); obj; end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/resolver.rb

@@ -28,6 +28,7 @@ module GraphQL
       extend Schema::Member::HasPath
       extend Schema::Member::HasDirectives
       include Schema::Member::HasDataloader
+      extend Schema::Member::HasDeprecationReason
 
       # @param object [Object] The application object that this field is being resolved on
       # @param context [GraphQL::Query::Context]

data/lib/graphql/schema/scalar.rb

@@ -50,12 +50,7 @@ module GraphQL
           end
 
           if coerced_result.nil?
-            str_value = if value == Float::INFINITY
-              ""
-            else
-              " #{GraphQL::Language.serialize(value)}"
-            end
-            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
             Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
           else

data/lib/graphql/schema/timeout.rb

@@ -71,15 +71,23 @@ module GraphQL
         def execute_field(query:, field:, **_rest)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
-          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          if timeout_state == false
+            super
+          elsif Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
               @timeout.handle_timeout(error, query)
+              timeout_state = query.context.namespace(@timeout).fetch(:state)
             end
 
-            error
+            # `handle_timeout` may have set this to be `false`
+            if timeout_state != false
+              error
+            else
+              super
+            end
           else
             super
           end
@@ -102,6 +110,15 @@ module GraphQL
         # override to do something interesting
       end
 
+      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # for the given query.
+      # @param query [GraphQL::Query]
+      # @return [void]
+      def disable_timeout(query)
+        query.context.namespace(self)[:state] = false
+        nil
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/validator/required_validator.rb

@@ -96,26 +96,35 @@ module GraphQL
         end
 
         def build_message(context)
-          argument_definitions = @validated.arguments(context).values
+          argument_definitions = context.types.arguments(@validated)
+
           required_names = @one_of.map do |arg_keyword|
             if arg_keyword.is_a?(Array)
-              names = arg_keyword.map { |arg| arg_keyword_to_grapqhl_name(argument_definitions, arg) }
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else
-              arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+              arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
             end
           end
+          required_names.compact! # remove entries for hidden arguments
+
 
-          if required_names.size == 1
+          case required_names.size
+          when 0
+            # The required definitions were hidden from the client.
+            # Another option here would be to raise an error in the application....
+            "%{validated} is missing a required argument."
+          when 1
             "%{validated} must include the following argument: #{required_names.first}."
           else
             "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
           end
         end
 
-        def arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+        def arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
           argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
-          argument_definition.graphql_name
+          argument_definition&.graphql_name
         end
       end
     end

data/lib/graphql/schema/visibility/migration.rb

@@ -76,10 +76,10 @@ module GraphQL
           end
         end
 
-        def initialize(context:, schema:, name: nil)
+        def initialize(context:, schema:, name: nil, visibility:)
           @name = name
           @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
-          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema, visibility: visibility)
           if !@skip_error
             context[:visibility_migration_running] = true
             warden_ctx_vals = context.to_h.dup

data/lib/graphql/schema/visibility/profile.rb

@@ -31,10 +31,37 @@ module GraphQL
         # @return [Symbol, nil]
         attr_reader :name
 
-        def initialize(name: nil, context:, schema:)
+        def freeze
+          @cached_visible.default_proc = nil
+          @cached_visible_fields.default_proc = nil
+          @cached_visible_fields.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_visible_arguments.default_proc = nil
+          @cached_visible_arguments.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_parent_fields.default_proc = nil
+          @cached_parent_fields.each do |type, fields|
+            fields.default_proc = nil
+          end
+          @cached_parent_arguments.default_proc = nil
+          @cached_parent_arguments.each do |type, args|
+            args.default_proc = nil
+          end
+          @cached_possible_types.default_proc = nil
+          @cached_enum_values.default_proc = nil
+          @cached_fields.default_proc = nil
+          @cached_arguments.default_proc = nil
+          @loadable_possible_types.default_proc = nil
+          super
+        end
+
+        def initialize(name: nil, context:, schema:, visibility:)
           @name = name
           @context = context
           @schema = schema
+          @visibility = visibility
           @all_types = {}
           @all_types_loaded = false
           @unvisited_types = []
@@ -47,12 +74,21 @@ module GraphQL
             end.compare_by_identity
           }.compare_by_identity
 
-          @cached_visible_arguments = Hash.new do |h, arg|
-            h[arg] = if @cached_visible[arg] && (arg_type = arg.type.unwrap) && @cached_visible[arg_type]
-              true
-            else
-              false
-            end
+          @cached_visible_arguments = Hash.new do |h, owner|
+            h[owner] = Hash.new do |h2, arg|
+              h2[arg] = if @cached_visible[arg] && (arg_type = arg.type.unwrap) && @cached_visible[arg_type]
+                case owner
+                when GraphQL::Schema::Field
+                  @cached_visible_fields[owner.owner][owner]
+                when Class
+                  @cached_visible[owner]
+                else
+                  raise "Unexpected argument owner for `#{arg.path}`: #{owner.inspect}"
+                end
+              else
+                false
+              end
+            end.compare_by_identity
           end.compare_by_identity
 
           @cached_parent_fields = Hash.new do |h, type|
@@ -82,7 +118,7 @@ module GraphQL
           end.compare_by_identity
 
           @cached_arguments = Hash.new do |h, owner|
-            h[owner] = non_duplicate_items(owner.all_argument_definitions, @cached_visible_arguments)
+            h[owner] = non_duplicate_items(owner.all_argument_definitions, @cached_visible_arguments[owner])
           end.compare_by_identity
 
           @loadable_possible_types = Hash.new { |h, union_type| h[union_type] = union_type.possible_types }.compare_by_identity
@@ -113,7 +149,7 @@ module GraphQL
         end
 
         def type(type_name)
-          t = @schema.visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+          t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if t
             if t.is_a?(Array)
               vis_t = nil
@@ -180,7 +216,7 @@ module GraphQL
           if arg.is_a?(Array)
             visible_arg = nil
             arg.each do |arg_defn|
-              if @cached_visible_arguments[arg_defn]
+              if @cached_visible_arguments[owner][arg_defn]
                 if visible_arg.nil?
                   visible_arg = arg_defn
                 else
@@ -190,7 +226,7 @@ module GraphQL
             end
             visible_arg
           else
-            if arg && @cached_visible_arguments[arg]
+            if arg && @cached_visible_arguments[owner][arg]
               arg
             else
               nil
@@ -241,14 +277,13 @@ module GraphQL
         end
 
         def directives
-          @all_directives ||= @schema.visibility.all_directives.select { |dir|
-            @cached_visible[dir] && @schema.visibility.all_references[dir].any? { |ref| ref == true || (@cached_visible[ref] && referenced?(ref)) }
+          @all_directives ||= @visibility.all_directives.select { |dir|
+            @cached_visible[dir] && @visibility.all_references[dir].any? { |ref| ref == true || (@cached_visible[ref] && referenced?(ref)) }
           }
         end
 
         def loadable?(t, _ctx)
-          load_all_types
-          !@all_types[t.graphql_name] && @cached_visible[t]
+          @cached_visible[t] && !referenced?(t)
         end
 
         def loadable_possible_types(t, _ctx)
@@ -268,13 +303,51 @@ module GraphQL
           @cached_visible[enum_value]
         end
 
+        def preload
+          load_all_types
+          @all_types.each do |type_name, type_defn|
+            if type_defn.kind.fields?
+              fields(type_defn).each do |f|
+                field(type_defn, f.graphql_name)
+                arguments(f).each do |arg|
+                  argument(f, arg.graphql_name)
+                end
+              end
+              @schema.introspection_system.dynamic_fields.each do |f|
+                field(type_defn, f.graphql_name)
+              end
+            elsif type_defn.kind.input_object?
+              arguments(type_defn).each do |arg|
+                argument(type_defn, arg.graphql_name)
+              end
+            elsif type_defn.kind.enum?
+              enum_values(type_defn)
+            end
+            # Lots more to do here
+          end
+          @schema.introspection_system.entry_points.each do |f|
+            arguments(f).each do |arg|
+              argument(f, arg.graphql_name)
+            end
+            field(@schema.query, f.graphql_name)
+          end
+          @schema.introspection_system.dynamic_fields.each do |f|
+            arguments(f).each do |arg|
+              argument(f, arg.graphql_name)
+            end
+          end
+
+        end
+
         private
 
         def non_duplicate_items(definitions, visibility_cache)
           non_dups = []
+          names = Set.new
           definitions.each do |defn|
             if visibility_cache[defn]
-              if (dup_defn = non_dups.find { |d| d.graphql_name == defn.graphql_name })
+              if !names.add?(defn.graphql_name)
+                dup_defn = non_dups.find { |d| d.graphql_name == defn.graphql_name }
                 raise_duplicate_definition(dup_defn, defn)
               end
               non_dups << defn
@@ -292,7 +365,7 @@ module GraphQL
           @all_types_loaded = true
           visit = Visibility::Visit.new(@schema) do |member|
             if member.is_a?(Module) && member.respond_to?(:kind)
-              if @cached_visible[member]
+              if @cached_visible[member] && referenced?(member)
                 type_name = member.graphql_name
                 if (prev_t = @all_types[type_name]) && !prev_t.equal?(member)
                   raise_duplicate_definition(member, prev_t)
@@ -312,16 +385,29 @@ module GraphQL
         end
 
         def referenced?(type_defn)
-          @schema.visibility.all_references[type_defn].any? { |r| r == true ||  @cached_visible[r] }
+          @visibility.all_references[type_defn].any? do |ref|
+            case ref
+            when GraphQL::Schema::Argument
+              @cached_visible_arguments[ref.owner][ref]
+            when GraphQL::Schema::Field
+              @cached_visible_fields[ref.owner][ref]
+            when Module
+              @cached_visible[ref]
+            when true
+              true
+            end
+          end
         end
 
         def possible_types_for(type)
           case type.kind.name
           when "INTERFACE"
             pts = []
-            @schema.visibility.all_interface_type_memberships[type].each do |(itm, impl_type)|
-              if @cached_visible[itm] && @cached_visible[impl_type] && referenced?(impl_type)
-                pts << impl_type
+            @visibility.all_interface_type_memberships[type].each do |impl_type, type_memberships|
+              if impl_type.kind.object? && referenced?(impl_type) && @cached_visible[impl_type]
+                if type_memberships.any? { |itm| @cached_visible[itm] }
+                  pts << impl_type
+                end
               end
             end
             pts

data/lib/graphql/schema/visibility.rb

@@ -12,15 +12,12 @@ module GraphQL
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
       # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze
         }
         schema.visibility = self.new(schema, dynamic: dynamic, preload: preload, profiles: profiles, migration_errors: migration_errors)
-        if preload
-          schema.visibility.preload
-        end
       end
 
       def initialize(schema, dynamic:, preload:, profiles:, migration_errors:)
@@ -43,6 +40,17 @@ module GraphQL
         @types = nil
         @all_references = nil
         @loaded_all = false
+        if preload
+          self.preload
+        end
+      end
+
+      def freeze
+        load_all
+        @visit = true
+        @interface_type_memberships.default_proc = nil
+        @all_references.default_proc = nil
+        super
       end
 
       def all_directives
@@ -65,6 +73,8 @@ module GraphQL
         @types[type_name]
       end
 
+      attr_accessor :types
+
       def preload?
         @preload
       end
@@ -86,7 +96,7 @@ module GraphQL
         ensure_all_loaded(types_to_visit)
         @profiles.each do |profile_name, example_ctx|
           prof = profile_for(example_ctx)
-          prof.all_types # force loading
+          prof.preload
         end
       end
 
@@ -148,28 +158,27 @@ module GraphQL
 
       attr_reader :cached_profiles
 
-      def profile_for(context, visibility_profile = context[:visibility_profile])
+      def profile_for(context)
         if !@profiles.empty?
-          if visibility_profile.nil?
-            if @dynamic
-              if context.is_a?(Query::NullContext)
-                top_level_profile
-              else
-                @schema.visibility_profile_class.new(context: context, schema: @schema)
-              end
-            elsif !@profiles.empty?
-              raise ArgumentError, "#{@schema} expects a visibility profile, but `visibility_profile:` wasn't passed. Provide a `visibility_profile:` value or add `dynamic: true` to your visibility configuration."
+          visibility_profile = context[:visibility_profile]
+          if @profiles.include?(visibility_profile)
+            profile_ctx = @profiles[visibility_profile]
+            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: profile_ctx, schema: @schema, visibility: self)
+          elsif @dynamic
+            if context.is_a?(Query::NullContext)
+              top_level_profile
+            else
+              @schema.visibility_profile_class.new(context: context, schema: @schema, visibility: self)
             end
-          elsif !@profiles.include?(visibility_profile)
-            raise ArgumentError, "`#{visibility_profile.inspect}` isn't allowed for `visibility_profile:` (must be one of #{@profiles.keys.map(&:inspect).join(", ")}). Or, add `#{visibility_profile.inspect}` to the list of profiles in the schema definition."
+          elsif !context.key?(:visibility_profile)
+            raise ArgumentError, "#{@schema} expects a visibility profile, but `visibility_profile:` wasn't passed. Provide a `visibility_profile:` value or add `dynamic: true` to your visibility configuration."
           else
-            profile_ctx = @profiles[visibility_profile]
-            @cached_profiles[visibility_profile] ||= @schema.visibility_profile_class.new(name: visibility_profile, context: profile_ctx, schema: @schema)
+            raise ArgumentError, "`#{visibility_profile.inspect}` isn't allowed for `visibility_profile:` (must be one of #{@profiles.keys.map(&:inspect).join(", ")}). Or, add `#{visibility_profile.inspect}` to the list of profiles in the schema definition."
           end
         elsif context.is_a?(Query::NullContext)
           top_level_profile
         else
-          @schema.visibility_profile_class.new(context: context, schema: @schema)
+          @schema.visibility_profile_class.new(context: context, schema: @schema, visibility: self)
         end
       end
 
@@ -182,7 +191,7 @@ module GraphQL
         if refresh
           @top_level_profile = nil
         end
-        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema)
+        @top_level_profile ||= @schema.visibility_profile_class.new(context: Query::NullContext.instance, schema: @schema, visibility: self)
       end
 
       private
@@ -203,7 +212,11 @@ module GraphQL
       def load_all(types: nil)
         if @visit.nil?
           # Set up the visit system
-          @interface_type_memberships = Hash.new { |h, interface_type| h[interface_type] = [] }.compare_by_identity
+          @interface_type_memberships = Hash.new { |h, interface_type|
+            h[interface_type] = Hash.new { |h2, obj_type|
+              h2[obj_type] = []
+            }.compare_by_identity
+          }.compare_by_identity
           @directives = []
           @types = {} # String => Module
           @all_references = Hash.new { |h, member| h[member] = Set.new.compare_by_identity }.compare_by_identity
@@ -228,7 +241,7 @@ module GraphQL
                   @all_references[itm.abstract_type] << member
                   # `itm.object_type` may not actually be `member` if this implementation
                   # is inherited from a superclass
-                  @interface_type_memberships[itm.abstract_type] << [itm, member]
+                  @interface_type_memberships[itm.abstract_type][member] << itm
                 end
               elsif member < GraphQL::Schema::Union
                 @unions_for_references << member
@@ -277,12 +290,11 @@ module GraphQL
 
         # TODO: somehow don't iterate over all these,
         # only the ones that may have been modified
-        @interface_type_memberships.each do |int_type, type_membership_pairs|
-          referers = @all_references[int_type].select { |r| r.is_a?(GraphQL::Schema::Field) }
-          if !referers.empty?
-            type_membership_pairs.each do |(type_membership, impl_type)|
-              # Add new items only:
-              @all_references[impl_type] |= referers
+        @interface_type_memberships.each do |int_type, obj_type_memberships|
+          referrers = @all_references[int_type].select { |r| r.is_a?(GraphQL::Schema::Field) }
+          if !referrers.empty?
+            obj_type_memberships.each_key do |impl_type|
+              @all_references[impl_type] |= referrers
             end
           end
         end

data/lib/graphql/schema/warden.rb

@@ -107,7 +107,7 @@ module GraphQL
         def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
         def reachable_type?(type_name); true; end
         def loadable?(type, _ctx); true; end
-        def loadable_possible_types(union_type, _ctx); union_type.possible_types; end
+        def loadable_possible_types(abstract_type, _ctx); union_type.possible_types; end
         def reachable_types; @schema.types.values; end # rubocop:disable Development/ContextIsPassedCop
         def possible_types(type_defn); @schema.possible_types(type_defn, Query::NullContext.instance, false); end
         def interfaces(obj_type); obj_type.interfaces; end
@@ -232,14 +232,22 @@ module GraphQL
 
       # @return [Boolean] True if this type is used for `loads:` but not in the schema otherwise and not _explicitly_ hidden.
       def loadable?(type, _ctx)
-        !reachable_type_set.include?(type) && visible_type?(type)
+        visible_type?(type) &&
+          !referenced?(type) &&
+          (type.respond_to?(:interfaces) ? interfaces(type).all? { |i| loadable?(i, _ctx) } : true)
       end
 
-      def loadable_possible_types(union_type, _ctx)
+      # This abstract type was determined to be used for `loads` only.
+      # All its possible types are valid possibilities here -- no filtering.
+      def loadable_possible_types(abstract_type, _ctx)
         @loadable_possible_types ||= read_through do |t|
-          t.possible_types # unfiltered
+          if t.is_a?(Class) # union
+            t.possible_types
+          else
+            @schema.possible_types(abstract_type)
+          end
         end
-        @loadable_possible_types[union_type]
+        @loadable_possible_types[abstract_type]
       end
 
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)