graphql 2.3.5 → 2.3.11

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to validate each member of an array value.
+      #
+      # @example validate format of all strings in an array
+      #
+      #   argument :handles, [String],
+      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ } } }
+      #
+      # @example multiple validators can be combined
+      #
+      #   argument :handles, [String],
+      #     validates: { all: { format: { with: /\A[a-z0-9_]+\Z/ }, length: { maximum: 32 } } }
+      #
+      # @example any type can be used
+      #
+      #   argument :choices, [Integer],
+      #     validates: { all: { inclusion: { in: 1..12 } } }
+      #
+      class AllValidator < Validator
+        def initialize(validated:, allow_blank: false, allow_null: false, **validators)
+          super(validated: validated, allow_blank: allow_blank, allow_null: allow_null)
+
+          @validators = Validator.from_config(validated, validators)
+        end
+
+        def validate(object, context, value)
+          all_errors = EMPTY_ARRAY
+
+          value.each do |subvalue|
+            @validators.each do |validator|
+              errors = validator.validate(object, context, subvalue)
+              if errors &&
+                  (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
+                  (errors.is_a?(String))
+                if all_errors.frozen? # It's empty
+                  all_errors = []
+                end
+                if errors.is_a?(String)
+                  all_errors << errors
+                else
+                  all_errors.concat(errors)
+                end
+              end
+            end
+          end
+
+          unless all_errors.frozen?
+            all_errors.uniq!
+          end
+
+          all_errors
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validator.rb

@@ -169,3 +169,5 @@ require "graphql/schema/validator/allow_null_validator"
 GraphQL::Schema::Validator.install(:allow_null, GraphQL::Schema::Validator::AllowNullValidator)
 require "graphql/schema/validator/allow_blank_validator"
 GraphQL::Schema::Validator.install(:allow_blank, GraphQL::Schema::Validator::AllowBlankValidator)
+require "graphql/schema/validator/all_validator"
+GraphQL::Schema::Validator.install(:all, GraphQL::Schema::Validator::AllValidator)

data/lib/graphql/schema/warden.rb

@@ -61,14 +61,27 @@ module GraphQL
           def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
           def arguments(owner, ctx); owner.arguments(ctx); end
           def loadable?(type, ctx); type.visible?(ctx); end
+          def schema_subset
+            @schema_subset ||= Warden::SchemaSubset.new(self)
+          end
         end
       end
 
       class NullWarden
         def initialize(_filter = nil, context:, schema:)
           @schema = schema
+          @schema_subset = Warden::SchemaSubset.new(self)
+        end
+
+        # @api private
+        module NullSubset
+          def self.new(context:, schema:)
+            NullWarden.new(context: context, schema: schema).schema_subset
+          end
         end
 
+        attr_reader :schema_subset
+
         def visible_field?(field_defn, _ctx = nil, owner = nil); true; end
         def visible_argument?(arg_defn, _ctx = nil); true; end
         def visible_type?(type_defn, _ctx = nil); true; end
@@ -91,6 +104,80 @@ module GraphQL
         def interfaces(obj_type); obj_type.interfaces; end
       end
 
+      def schema_subset
+        @schema_subset ||= SchemaSubset.new(self)
+      end
+
+      class SchemaSubset
+        def initialize(warden)
+          @warden = warden
+        end
+
+        def directives
+          @warden.directives
+        end
+
+        def directive_exists?(dir_name)
+          @warden.directives.any? { |d| d.graphql_name == dir_name }
+        end
+
+        def type(name)
+          @warden.get_type(name)
+        end
+
+        def field(owner, field_name)
+          @warden.get_field(owner, field_name)
+        end
+
+        def argument(owner, arg_name)
+          @warden.get_argument(owner, arg_name)
+        end
+
+        def query_root
+          @warden.root_type_for_operation("query")
+        end
+
+        def mutation_root
+          @warden.root_type_for_operation("mutation")
+        end
+
+        def subscription_root
+          @warden.root_type_for_operation("subscription")
+        end
+
+        def arguments(owner)
+          @warden.arguments(owner)
+        end
+
+        def fields(owner)
+          @warden.fields(owner)
+        end
+
+        def possible_types(type)
+          @warden.possible_types(type)
+        end
+
+        def enum_values(enum_type)
+          @warden.enum_values(enum_type)
+        end
+
+        def all_types
+          @warden.reachable_types
+        end
+
+        def interfaces(obj_type)
+          @warden.interfaces(obj_type)
+        end
+
+        def loadable?(t, ctx) # TODO remove ctx here?
+          @warden.loadable?(t, ctx)
+        end
+
+        def reachable_type?(type_name)
+          !!@warden.reachable_type?(type_name)
+        end
+      end
+
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
       def initialize(context:, schema:)
@@ -101,13 +188,12 @@ module GraphQL
         @subscription = @schema.subscription
         @context = context
         @visibility_cache = read_through { |m| schema.visible?(m, context) }
-        @visibility_cache.compare_by_identity
         # 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 =
-          @reachable_type_set =
+          @reachable_type_set = @schema_subset =
             nil
       end
 
@@ -376,9 +462,7 @@ module GraphQL
       end
 
       def read_through
-        h = Hash.new { |h, k| h[k] = yield(k) }
-        h.compare_by_identity
-        h
+        Hash.new { |h, k| h[k] = yield(k) }.compare_by_identity
       end
 
       def reachable_type_set

data/lib/graphql/schema.rb

@@ -5,7 +5,6 @@ require "graphql/schema/always_visible"
 require "graphql/schema/base_64_encoder"
 require "graphql/schema/find_inherited_value"
 require "graphql/schema/finder"
-require "graphql/schema/invalid_type_error"
 require "graphql/schema/introspection_system"
 require "graphql/schema/late_bound_type"
 require "graphql/schema/null_mask"
@@ -46,6 +45,8 @@ require "graphql/schema/mutation"
 require "graphql/schema/has_single_input_argument"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/subscription"
+require "graphql/schema/subset"
+require "graphql/schema/types_migration"
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
@@ -338,6 +339,9 @@ module GraphQL
       # @return [Hash<String => Class>] A dictionary of type classes by their GraphQL name
       # @see get_type Which is more efficient for finding _one type_ by name, because it doesn't merge hashes.
       def types(context = GraphQL::Query::NullContext.instance)
+        if use_schema_subset?
+          return Subset.from_context(context, self).all_types_h
+        end
         all_types = non_introspection_types.merge(introspection_system.types)
         visible_types = {}
         all_types.each do |k, v|
@@ -365,25 +369,32 @@ module GraphQL
       # @param type_name [String]
       # @return [Module, nil] A type, or nil if there's no type called `type_name`
       def get_type(type_name, context = GraphQL::Query::NullContext.instance)
+        if use_schema_subset?
+          return Subset.from_context(context, self).type(type_name)
+        end
         local_entry = own_types[type_name]
         type_defn = case local_entry
         when nil
           nil
         when Array
-          visible_t = nil
-          warden = Warden.from_context(context)
-          local_entry.each do |t|
-            if warden.visible_type?(t, context)
-              if visible_t.nil?
-                visible_t = t
-              else
-                raise DuplicateNamesError.new(
-                  duplicated_name: type_name, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
-                )
+          if context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+            local_entry
+          else
+            visible_t = nil
+            warden = Warden.from_context(context)
+            local_entry.each do |t|
+              if warden.visible_type?(t, context)
+                if visible_t.nil?
+                  visible_t = t
+                else
+                  raise DuplicateNamesError.new(
+                    duplicated_name: type_name, duplicated_definition_1: visible_t.inspect, duplicated_definition_2: t.inspect
+                  )
+                end
               end
             end
+            visible_t
           end
-          visible_t
         when Module
           local_entry
         else
@@ -419,17 +430,13 @@ module GraphQL
         end
       end
 
-      def new_connections?
-        !!connections
-      end
-
       def query(new_query_object = nil)
         if new_query_object
           if @query_object
             raise GraphQL::Error, "Second definition of `query(...)` (#{new_query_object.inspect}) is invalid, already configured with #{@query_object.inspect}"
           else
             @query_object = new_query_object
-            add_type_and_traverse(new_query_object, root: true)
+            add_type_and_traverse(new_query_object, root: true) unless use_schema_subset?
             nil
           end
         else
@@ -443,7 +450,7 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `mutation(...)` (#{new_mutation_object.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
           else
             @mutation_object = new_mutation_object
-            add_type_and_traverse(new_mutation_object, root: true)
+            add_type_and_traverse(new_mutation_object, root: true) unless use_schema_subset?
             nil
           end
         else
@@ -458,7 +465,7 @@ module GraphQL
           else
             @subscription_object = new_subscription_object
             add_subscription_extension_if_necessary
-            add_type_and_traverse(new_subscription_object, root: true)
+            add_type_and_traverse(new_subscription_object, root: true) unless use_schema_subset?
             nil
           end
         else
@@ -482,7 +489,11 @@ module GraphQL
       end
 
       def root_types
-        @root_types
+        if use_schema_subset?
+          [query, mutation, subscription].compact
+        else
+          @root_types
+        end
       end
 
       def warden_class
@@ -497,10 +508,39 @@ module GraphQL
 
       attr_writer :warden_class
 
+      def subset_class
+        if defined?(@subset_class)
+          @subset_class
+        elsif superclass.respond_to?(:subset_class)
+          superclass.subset_class
+        else
+          GraphQL::Schema::Subset
+        end
+      end
+
+      attr_writer :subset_class, :use_schema_subset
+
+      def use_schema_subset?
+        if defined?(@use_schema_subset)
+          @use_schema_subset
+        elsif superclass.respond_to?(:use_schema_subset?)
+          superclass.use_schema_subset?
+        else
+          false
+        end
+      end
+
       # @param type [Module] The type definition whose possible types you want to see
       # @return [Hash<String, Module>] All possible types, if no `type` is given.
       # @return [Array<Module>] Possible types for `type`, if it's given.
       def possible_types(type = nil, context = GraphQL::Query::NullContext.instance)
+        if use_schema_subset?
+          if type
+            return Subset.from_context(context, self).possible_types(type)
+          else
+            raise "Schema.possible_types is not implemented for `use_schema_subset?`"
+          end
+        end
         if type
           # TODO duck-typing `.possible_types` would probably be nicer here
           if type.kind.union?
@@ -573,9 +613,8 @@ module GraphQL
         end
       end
 
-      def type_from_ast(ast_node, context: nil)
-        type_owner = context ? context.warden : self
-        GraphQL::Schema::TypeExpression.build_type(type_owner, ast_node)
+      def type_from_ast(ast_node, context: self.query_class.new(self, "{ __typename }").context)
+        GraphQL::Schema::TypeExpression.build_type(context.query.types, ast_node)
       end
 
       def get_field(type_or_name, field_name, context = GraphQL::Query::NullContext.instance)
@@ -769,16 +808,6 @@ module GraphQL
         @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
-      def using_ast_analysis?
-        true
-      end
-
-      def interpreter?
-        true
-      end
-
-      attr_writer :interpreter
-
       def error_bubbling(new_error_bubbling = nil)
         if !new_error_bubbling.nil?
           warn("error_bubbling(#{new_error_bubbling.inspect}) is deprecated; the default value of `false` will be the only option in GraphQL-Ruby 3.0")
@@ -887,7 +916,7 @@ module GraphQL
               To add other types to your schema, you might want `extra_types`: https://graphql-ruby.org/schema/definition.html#extra-types
             ERR
           end
-          add_type_and_traverse(new_orphan_types, root: false)
+          add_type_and_traverse(new_orphan_types, root: false) unless use_schema_subset?
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
@@ -1053,6 +1082,10 @@ module GraphQL
         Member::HasDirectives.get_directives(self, @own_schema_directives, :schema_directives)
       end
 
+      # Called when a type is needed by name at runtime
+      def load_type(type_name, ctx)
+        get_type(type_name, ctx)
+      end
       # This hook is called when an object fails an `authorized?` check.
       # You might report to your bug tracker here, so you can correct
       # the field resolvers not to return unauthorized objects.
@@ -1142,7 +1175,11 @@ module GraphQL
       # @param new_directive [Class]
       # @return void
       def directive(new_directive)
-        add_type_and_traverse(new_directive, root: false)
+        if use_schema_subset?
+          own_directives[new_directive.graphql_name] = new_directive
+        else
+          add_type_and_traverse(new_directive, root: false)
+        end
       end
 
       def default_directives
@@ -1485,7 +1522,7 @@ module GraphQL
       end
 
       def own_references_to
-        @own_references_to ||= {}.tap(&:compare_by_identity)
+        @own_references_to ||= {}.compare_by_identity
       end
 
       def non_introspection_types
@@ -1501,7 +1538,7 @@ module GraphQL
       end
 
       def own_possible_types
-        @own_possible_types ||= {}.tap(&:compare_by_identity)
+        @own_possible_types ||= {}.compare_by_identity
       end
 
       def own_union_memberships

data/lib/graphql/static_validation/base_visitor.rb

@@ -10,6 +10,7 @@ module GraphQL
         @argument_definitions = []
         @directive_definitions = []
         @context = context
+        @types = context.query.types
         @schema = context.schema
         super(document)
       end
@@ -77,7 +78,7 @@ module GraphQL
 
         def on_field(node, parent)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name, @context.query.context)
+          field_definition = @types.field(parent_type, node.name)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -103,14 +104,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              @context.warden.get_argument(arg_type, node.name)
+              @types.argument(arg_type, node.name)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            @context.warden.get_argument(directive_defn, node.name)
+            @types.argument(directive_defn, node.name)
           elsif (field_defn = @field_definitions.last)
-            @context.warden.get_argument(field_defn, node.name)
+            @types.argument(field_defn, node.name)
           else
             nil
           end
@@ -170,7 +171,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @context.warden.get_type(node.type.name)
+            @types.type(node.type.name)
           else
             @object_types.last
           end

data/lib/graphql/static_validation/literal_validator.rb

@@ -5,7 +5,7 @@ module GraphQL
     class LiteralValidator
       def initialize(context:)
         @context = context
-        @warden = context.warden
+        @types = context.types
         @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
         @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
@@ -109,7 +109,7 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = @warden.arguments(type)
+        required_field_names = @types.arguments(type)
           .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
           .map!(&:name)
 
@@ -119,7 +119,7 @@ module GraphQL
           missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
           results = missing_required_field_names.map do |name|
-            arg_type = @warden.get_argument(type, name).type
+            arg_type = @types.argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
           if type.one_of? && ast_node.arguments.size != 1
@@ -131,7 +131,7 @@ module GraphQL
 
       def present_input_field_values_are_valid(type, ast_node)
         results = ast_node.arguments.map do |value|
-          field = @warden.get_argument(type, value.name)
+          field = @types.argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
           field_type = field && field.type

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

@@ -15,7 +15,7 @@ module GraphQL
         if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
           parent_defn = parent_definition(parent)
 
-          if parent_defn && (arg_defn = context.warden.get_argument(parent_defn, node.name))
+          if parent_defn && (arg_defn = @types.argument(parent_defn, node.name))
             validation_result = context.validate_literal(node.value, arg_defn.type)
             if !validation_result.valid?
               kind_of_node = node_type(parent)

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

@@ -5,7 +5,7 @@ module GraphQL
       def on_argument(node, parent)
         parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+        if parent_defn && @types.argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)

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

@@ -4,11 +4,10 @@ module GraphQL
     module DirectivesAreDefined
       def initialize(*)
         super
-        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
       def on_directive(node, parent)
-        if !@directive_names.include?(node.name)
+        if !@types.directive_exists?(node.name)
           @directives_are_defined_errors_by_name ||= {}
           error = @directives_are_defined_errors_by_name[node.name] ||= begin
             err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(

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

@@ -4,7 +4,7 @@ module GraphQL
     module FieldsAreDefinedOnType
       def on_field(node, parent)
         parent_type = @object_types[-2]
-        field = context.warden.get_field(parent_type, node.name)
+        field = context.query.types.field(parent_type, node.name)
 
         if field.nil?
           if parent_type.kind.union?

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

@@ -117,8 +117,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.warden.get_type(fragment1.type.name)
-        fragment_type2 = context.warden.get_type(fragment2.type.name)
+        fragment_type1 = context.query.types.type(fragment1.type.name)
+        fragment_type2 = context.query.types.type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -170,7 +170,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.warden.get_type(fragment.type.name)
+        fragment_type = @types.type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -340,10 +340,10 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.warden.get_field(owner_type, node.name)
+            definition = @types.field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type
+            fragment_type = node.type ? @types.type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
@@ -411,8 +411,8 @@ module GraphQL
               false
             else
               # Check if these two scopes have _any_ types in common.
-              possible_right_types = context.query.possible_types(type1)
-              possible_left_types = context.query.possible_types(type2)
+              possible_right_types = context.types.possible_types(type1)
+              possible_left_types = context.types.possible_types(type2)
               (possible_right_types & possible_left_types).empty?
             end
           end

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

@@ -28,7 +28,7 @@ module GraphQL
           frag_node = context.fragments[frag_spread.node.name]
           if frag_node
             fragment_child_name = frag_node.type.name
-            fragment_child = context.warden.get_type(fragment_child_name)
+            fragment_child = @types.type(fragment_child_name)
             # Might be non-existent type name
             if fragment_child
               validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
@@ -44,8 +44,8 @@ module GraphQL
           # It's not a valid fragment type, this error was handled someplace else
           return
         end
-        parent_types = context.warden.possible_types(parent_type.unwrap)
-        child_types = context.warden.possible_types(child_type.unwrap)
+        parent_types = @types.possible_types(parent_type.unwrap)
+        child_types = @types.possible_types(child_type.unwrap)
 
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""

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

@@ -21,7 +21,7 @@ module GraphQL
           true
         else
           type_name = fragment_node.type.name
-          type = context.warden.get_type(type_name)
+          type = @types.type(type_name)
           if type.nil?
             add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
               "No such type #{type_name}, so it can't be a fragment condition",

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

@@ -19,7 +19,7 @@ module GraphQL
           true
         else
           type_name = node_type.to_query_string
-          type_def = context.warden.get_type(type_name)
+          type_def = @types.type(type_name)
           if type_def.nil? || !type_def.kind.composite?
             add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
               "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",

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

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module MutationRootExists
       def on_operation_definition(node, _parent)
-        if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
+        if node.operation_type == 'mutation' && context.query.types.mutation_root.nil?
           add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
             'Schema is not configured for mutations',
             nodes: node

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

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module QueryRootExists
       def on_operation_definition(node, _parent)
-        if (node.operation_type == 'query' || node.operation_type.nil?) && context.warden.root_type_for_operation("query").nil?
+        if (node.operation_type == 'query' || node.operation_type.nil?) && context.query.types.query_root.nil?
           add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
             'Schema is not configured for queries',
             nodes: node