graphql 1.9.16 → 1.9.21

data/lib/graphql/schema/object.rb

@@ -35,10 +35,12 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = begin
-            authorized?(object, context)
-          rescue GraphQL::UnauthorizedError => err
-            context.schema.unauthorized_object(err)
+          auth_val = context.query.with_error_handling do
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            end
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|

data/lib/graphql/schema/possible_types.rb

@@ -20,12 +20,12 @@ module GraphQL
         end
       end
 
-      def possible_types(type_defn)
+      def possible_types(type_defn, ctx)
         case type_defn
         when Module
-          possible_types(type_defn.graphql_definition)
+          possible_types(type_defn.graphql_definition, ctx)
         when GraphQL::UnionType
-          type_defn.possible_types
+          type_defn.possible_types(ctx)
         when GraphQL::InterfaceType
           @interface_implementers[type_defn]
         when GraphQL::BaseType

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -61,7 +61,7 @@ module GraphQL
         end
 
         return_value = if input_kwargs.any?
-          super(input_kwargs)
+          super(**input_kwargs)
         else
           super()
         end

data/lib/graphql/schema/resolver.rb

@@ -76,7 +76,7 @@ module GraphQL
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
-                authorized?(loaded_args)
+                authorized?(**loaded_args)
               else
                 authorized?
               end

data/lib/graphql/schema/subscription.rb

@@ -39,12 +39,12 @@ module GraphQL
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
-        public_send("resolve_#{@mode}", args)
+        public_send("resolve_#{@mode}", **args)
       end
 
       # Wrap the user-defined `#subscribe` hook
-      def resolve_subscribe(args)
-        ret_val = args.any? ? subscribe(args) : subscribe
+      def resolve_subscribe(**args)
+        ret_val = args.any? ? subscribe(**args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -62,8 +62,8 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
-      def resolve_update(args)
-        ret_val = args.any? ? update(args) : update
+      def resolve_update(**args)
+        ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
           raise NoUpdateError
         else

data/lib/graphql/schema/type_membership.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class joins an object type to an abstract type (interface or union) of which
+    # it is a member.
+    #
+    # TODO: Not yet implemented for interfaces.
+    class TypeMembership
+      # @return [Class<GraphQL::Schema::Object>]
+      attr_reader :object_type
+
+      # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      attr_reader :abstract_type
+
+      # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
+      # or {Schema::Object.implements} (for interfaces).
+      #
+      # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param object_type [Class<GraphQL::Schema::Object>]
+      # @param options [Hash] Any options passed to `.possible_types` or `.implements`
+      def initialize(abstract_type, object_type, **options)
+        @abstract_type = abstract_type
+        @object_type = object_type
+        @options = options
+      end
+
+      # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
+      def visible?(_ctx)
+        true
+      end
+    end
+  end
+end

data/lib/graphql/schema/union.rb

@@ -5,13 +5,19 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
-        def possible_types(*types)
+        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
-            @possible_types = types
+            types.each do |t|
+              type_memberships << type_membership_class.new(self, t, **options)
+            end
           else
-            all_possible_types = @possible_types || []
-            all_possible_types += super if defined?(super)
-            all_possible_types.uniq
+            visible_types = []
+            type_memberships.each do |type_membership|
+              if type_membership.visible?(context)
+                visible_types << type_membership.object_type
+              end
+            end
+            visible_types
           end
         end
 
@@ -19,7 +25,7 @@ module GraphQL
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name
           type_defn.description = description
-          type_defn.possible_types = possible_types
+          type_defn.type_memberships = type_memberships
           if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end
@@ -27,9 +33,23 @@ module GraphQL
           type_defn
         end
 
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::UNION
         end
+
+        private
+
+        def type_memberships
+          @type_memberships ||= []
+        end
       end
     end
   end

data/lib/graphql/schema/warden.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'set'
+
 module GraphQL
   class Schema
     # Restrict access to a {GraphQL::Schema} with a user-defined filter.
@@ -40,7 +43,8 @@ module GraphQL
       # @param deep_check [Boolean]
       def initialize(filter, context:, schema:)
         @schema = schema
-        @visibility_cache = read_through { |m| filter.call(m, context) }
+        @context = context
+        @visibility_cache = read_through { |m| filter.call(m, @context) }
       end
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema
@@ -62,6 +66,17 @@ module GraphQL
         @visible_types[type_name]
       end
 
+      # @return [Array<GraphQL::BaseType>] Visible and reachable types in the schema
+      def reachable_types
+        @reachable_types ||= reachable_type_set.to_a
+      end
+
+      # @return Boolean True if the type is visible and reachable in the schema
+      def reachable_type?(type_name)
+        type = get_type(type_name)
+        type && reachable_type_set.include?(type)
+      end
+
       # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
       def get_field(parent_type, field_name)
 
@@ -81,7 +96,7 @@ module GraphQL
 
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
-        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
+        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn, @context).select { |t| visible_type?(t) } }
         @visible_possible_types[type_defn]
       end
 
@@ -170,7 +185,7 @@ module GraphQL
       end
 
       def visible_possible_types?(type_defn)
-        @schema.possible_types(type_defn).any? { |t| visible_type?(t) }
+        @schema.possible_types(type_defn, @context).any? { |t| visible_type?(t) }
       end
 
       def visible?(member)
@@ -180,6 +195,65 @@ module GraphQL
       def read_through
         Hash.new { |h, k| h[k] = yield(k) }
       end
+
+      def reachable_type_set
+        return @reachable_type_set if defined?(@reachable_type_set)
+
+        @reachable_type_set = Set.new
+
+        unvisited_types = []
+        ['query', 'mutation', 'subscription'].each do |op_name|
+          root_type = root_type_for_operation(op_name)
+          unvisited_types << root_type if root_type
+        end
+        unvisited_types.concat(@schema.introspection_system.object_types)
+        @schema.orphan_types.each do |orphan_type|
+          unvisited_types << orphan_type.graphql_definition if get_type(orphan_type.graphql_name)
+        end
+
+        until unvisited_types.empty?
+          type = unvisited_types.pop
+          if @reachable_type_set.add?(type)
+            if type.kind.input_object?
+              # recurse into visible arguments
+              arguments(type).each do |argument|
+                argument_type = argument.type.unwrap
+                unvisited_types << argument_type
+              end
+            elsif type.kind.union?
+              # recurse into visible possible types
+              possible_types(type).each do |possible_type|
+                unvisited_types << possible_type
+              end
+            elsif type.kind.fields?
+              if type.kind.interface?
+                # recurse into visible possible types
+                possible_types(type).each do |possible_type|
+                  unvisited_types << possible_type
+                end
+              elsif type.kind.object?
+                # recurse into visible implemented interfaces
+                interfaces(type).each do |interface|
+                  unvisited_types << interface
+                end
+              end
+
+              # recurse into visible fields
+              fields(type).each do |field|
+                field_type = field.type.unwrap
+                unvisited_types << field_type
+                # recurse into visible arguments
+                arguments(field).each do |argument|
+                  argument_type = argument.type.unwrap
+                  unvisited_types << argument_type
+                end
+              end
+            end
+          end
+        end
+
+        @reachable_type_set
+      end
     end
   end
 end

data/lib/graphql/subscriptions.rb

@@ -20,7 +20,7 @@ module GraphQL
     def self.use(defn, options = {})
       schema = defn.target
       options[:schema] = schema
-      schema.subscriptions = self.new(options)
+      schema.subscriptions = self.new(**options)
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:field, instrumentation)
       defn.instrument(:query, instrumentation)
@@ -90,7 +90,7 @@ module GraphQL
       operation_name = query_data.fetch(:operation_name)
       # Re-evaluate the saved query
       result = @schema.execute(
-        {
+        **{
           query: query_string,
           context: context,
           subscription_topic: event.topic,

data/lib/graphql/subscriptions/subscription_root.rb

@@ -40,7 +40,7 @@ module GraphQL
             # for the backend to register:
             events << Subscriptions::Event.new(
               name: field.name,
-              arguments: arguments,
+              arguments: arguments_without_field_extras(arguments: arguments),
               context: context,
               field: field,
             )
@@ -48,7 +48,7 @@ module GraphQL
             value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,
-              arguments,
+              arguments_without_field_extras(arguments: arguments),
               field,
               scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
             )
@@ -60,6 +60,14 @@ module GraphQL
             context.skip
           end
         end
+
+        private
+
+        def arguments_without_field_extras(arguments:)
+          arguments.dup.tap do |event_args|
+            field.extras.each { |k| event_args.delete(k) }
+          end
+        end
       end
     end
   end

data/lib/graphql/union_type.rb

@@ -24,22 +24,34 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types, :resolve_type
-    ensure_defined :possible_types, :resolve_type, :resolve_type_proc
+    # Rubocop was unhappy about the syntax when this was a proc literal
+    class AcceptPossibleTypesDefinition
+      def self.call(target, possible_types, options = {})
+        target.add_possible_types(possible_types, **options)
+      end
+    end
+
+    accepts_definitions :resolve_type, :type_membership_class,
+      possible_types: AcceptPossibleTypesDefinition
+    ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 
     attr_accessor :resolve_type_proc
+    attr_reader :type_memberships
+    attr_accessor :type_membership_class
 
     def initialize
       super
-      @dirty_possible_types = []
-      @clean_possible_types = nil
+      @type_membership_class = GraphQL::Schema::TypeMembership
+      @type_memberships = []
+      @cached_possible_types = nil
       @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
       super
-      @clean_possible_types = nil
-      @dirty_possible_types = other.dirty_possible_types.dup
+      @type_membership_class = other.type_membership_class
+      @type_memberships = other.type_memberships.dup
+      @cached_possible_types = nil
     end
 
     def kind
@@ -47,33 +59,44 @@ module GraphQL
     end
 
     # @return [Boolean] True if `child_type_defn` is a member of this {UnionType}
-    def include?(child_type_defn)
-      possible_types.include?(child_type_defn)
-    end
-
-    def possible_types=(new_possible_types)
-      @clean_possible_types = nil
-      @dirty_possible_types = new_possible_types
+    def include?(child_type_defn, ctx = GraphQL::Query::NullContext)
+      possible_types(ctx).include?(child_type_defn)
     end
 
     # @return [Array<GraphQL::ObjectType>] Types which may be found in this union
-    def possible_types
-      @clean_possible_types ||= begin
-        if @dirty_possible_types.respond_to?(:map)
-          @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-        else
-          @dirty_possible_types
-        end
+    def possible_types(ctx = GraphQL::Query::NullContext)
+      if ctx == GraphQL::Query::NullContext
+        # Only cache the default case; if we cached for every `ctx`, it would be a memory leak
+        # (The warden should cache calls to this method, so it's called only once per query,
+        # unless user code calls it directly.)
+        @cached_possible_types ||= possible_types_for_context(ctx)
+      else
+        possible_types_for_context(ctx)
       end
     end
 
+    def possible_types=(types)
+      # This is a re-assignment, so clear the previous values
+      @type_memberships = []
+      @cached_possible_types = nil
+      add_possible_types(types, **{})
+    end
+
+    def add_possible_types(types, **options)
+      @type_memberships ||= []
+      Array(types).each { |t|
+        @type_memberships << self.type_membership_class.new(self, t, **options)
+      }
+      nil
+    end
+
     # Get a possible type of this {UnionType} by type name
     # @param type_name [String]
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and is a member of this {UnionType}, (else `nil`)
     def get_possible_type(type_name, ctx)
       type = ctx.query.get_type(type_name)
-      type if type && ctx.query.schema.possible_types(self).include?(type)
+      type if type && ctx.query.schema.possible_types(self, ctx).include?(type)
     end
 
     # Check if a type is a possible type of this {UnionType}
@@ -93,8 +116,20 @@ module GraphQL
       @resolve_type_proc = new_resolve_type_proc
     end
 
-    protected
+    def type_memberships=(type_memberships)
+      @type_memberships = type_memberships
+    end
+
+    private
 
-    attr_reader :dirty_possible_types
+    def possible_types_for_context(ctx)
+      visible_types = []
+      @type_memberships.each do |type_membership|
+        if type_membership.visible?(ctx)
+          visible_types << BaseType.resolve_related_type(type_membership.object_type)
+        end
+      end
+      visible_types
+    end
   end
 end