graphql 1.13.14 → 2.0.19

data/lib/graphql/schema/timeout.rb

@@ -33,60 +33,56 @@ module GraphQL
     #   end
     #
     class Timeout
-      def self.use(schema, **options)
-        tracer = new(**options)
-        schema.tracer(tracer)
+      def self.use(schema, max_seconds: nil)
+        timeout = self.new(max_seconds: max_seconds)
+        schema.trace_with(self::Trace, timeout: timeout)
       end
 
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
-      def trace(key, data)
-        case key
-        when 'execute_multiplex'
-          data.fetch(:multiplex).queries.each do |query|
-            timeout_duration_s = max_seconds(query)
+      module Trace
+        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        def initialize(timeout:, **rest)
+          @timeout = timeout
+          super
+        end
+
+        def execute_multiplex(multiplex:)
+          multiplex.queries.each do |query|
+            timeout_duration_s = @timeout.max_seconds(query)
             timeout_state = if timeout_duration_s == false
               # if the method returns `false`, don't apply a timeout
               false
             else
               now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-              timeout_at = now + (max_seconds(query) * 1000)
+              timeout_at = now + (timeout_duration_s * 1000)
               {
                 timeout_at: timeout_at,
                 timed_out: false
               }
             end
-            query.context.namespace(self.class)[:state] = timeout_state
+            query.context.namespace(@timeout)[:state] = timeout_state
           end
+          super
+        end
 
-          yield
-        when 'execute_field', 'execute_field_lazy'
-          query_context = data[:context] || data[:query].context
-          timeout_state = query_context.namespace(self.class).fetch(:state)
+        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)
-            error = if data[:context]
-              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
-            else
-              field = data.fetch(:field)
-              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
-            end
-
+            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
-              handle_timeout(error, query_context.query)
+              @timeout.handle_timeout(error, query)
             end
 
             error
           else
-            yield
+            super
           end
-        else
-          yield
         end
       end
 
@@ -114,8 +110,8 @@ module GraphQL
       # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field)
-          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        def initialize(field)
+          super("Timeout on #{field.path}")
         end
       end
     end

data/lib/graphql/schema/type_membership.rb

@@ -11,6 +11,9 @@ module GraphQL
       # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
       attr_reader :abstract_type
 
+      # @return [Hash]
+      attr_reader :options
+
       # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
       # or {Schema::Object.implements} (for interfaces).
       #

data/lib/graphql/schema/union.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
@@ -33,21 +32,6 @@ module GraphQL
           type_memberships.map(&:object_type)
         end
 
-        prepend GraphQL::Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::UnionType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.ast_node = ast_node
-          type_defn.type_memberships = type_memberships
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn.metadata[:type_class] = self
-          type_defn
-        end
-
         def type_membership_class(membership_class = nil)
           if membership_class
             @type_membership_class = membership_class
@@ -86,9 +70,18 @@ module GraphQL
         private
 
         def assert_valid_union_member(type_defn)
-          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+          case type_defn
+          when Class
+            if !type_defn.kind.object?
+              raise ArgumentError, "Union possible_types can only be object types (not #{type_defn.kind.name}, #{type_defn.inspect})"
+            end
+          when Module
             # it's an interface type, defined as a module
             raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          when String, GraphQL::Schema::LateBoundType
+            # Ok - assume it will get checked later
+          else
+            raise ArgumentError, "Union possible_types can only be class-based GraphQL types (not #{type_defn.inspect} (#{type_defn.class.name}))."
           end
         end
       end

data/lib/graphql/schema/warden.rb

@@ -10,7 +10,7 @@ module GraphQL
     # should go through a warden. If you access the schema directly,
     # you may show a client something that it shouldn't be allowed to see.
     #
-    # @example Hidding private fields
+    # @example Hiding private fields
     #   private_members = -> (member, ctx) { member.metadata[:private] }
     #   result = Schema.execute(query_string, except: private_members)
     #
@@ -55,7 +55,9 @@ module GraphQL
               if visible_item.nil?
                 visible_item = item
               else
-                raise Schema::DuplicateNamesError, "Found two visible definitions for `#{item.path}`: #{visible_item.inspect}, #{item.inspect}"
+                raise DuplicateNamesError.new(
+                  duplicated_name: item.path, duplicated_definition_1: visible_item.inspect, duplicated_definition_2: item.inspect
+                )
               end
             end
           end
@@ -78,6 +80,8 @@ module GraphQL
           def visible_type?(type, ctx); type.visible?(ctx); end
           def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
           def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
+          def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
+          def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
@@ -85,13 +89,20 @@ module GraphQL
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
       def initialize(filter, context:, schema:)
-        @schema = schema.interpreter? ? schema : schema.graphql_definition
+        @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) }
+        # 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 =
+          @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @reachable_type_set =
+            nil
       end
 
       # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
@@ -172,14 +183,20 @@ module GraphQL
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
-      def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
+      def arguments(argument_owner, ctx = nil)
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
         @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        @visible_enum_arrays ||= read_through { |e| e.enum_values(@context) }
+        @visible_enum_arrays ||= read_through { |e|
+          values = e.enum_values(@context)
+          if values.size == 0
+            raise GraphQL::Schema::Enum::MissingValuesError.new(e)
+          end
+          values
+        }
         @visible_enum_arrays[enum_defn]
       end
 
@@ -231,6 +248,13 @@ module GraphQL
         visible?(type_membership)
       end
 
+      def interface_type_memberships(obj_type, _ctx = nil)
+        @type_memberships ||= read_through do |obj_t|
+          obj_t.interface_type_memberships
+        end
+        @type_memberships[obj_type]
+      end
+
       private
 
       def visible_and_reachable_type?(type_defn)
@@ -330,7 +354,7 @@ module GraphQL
       end
 
       def reachable_type_set
-        return @reachable_type_set if defined?(@reachable_type_set)
+        return @reachable_type_set if @reachable_type_set
 
         @reachable_type_set = Set.new
         rt_hash = {}
@@ -362,7 +386,9 @@ module GraphQL
           if @reachable_type_set.add?(type)
             type_by_name = rt_hash[type.graphql_name] ||= type
             if type_by_name != type
-              raise DuplicateNamesError, "Found two visible type definitions for `#{type.graphql_name}`: #{type.inspect}, #{type_by_name.inspect}"
+              raise DuplicateNamesError.new(
+                duplicated_name: type.graphql_name, duplicated_definition_1: type.inspect, duplicated_definition_2: type_by_name.inspect
+              )
             end
             if type.kind.input_object?
               # recurse into visible arguments

data/lib/graphql/schema/wrapper.rb

@@ -3,7 +3,6 @@
 module GraphQL
   class Schema
     class Wrapper
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::TypeSystemHelpers
 
       # @return [Class, Module] The inner type of this wrapping type, the type of which one or more objects may be present.
@@ -13,10 +12,6 @@ module GraphQL
         @of_type = of_type
       end
 
-      def to_graphql
-        raise GraphQL::RequiredImplementationMissingError
-      end
-
       def unwrap
         @of_type.unwrap
       end