graphql 2.3.5 → 2.3.14

data/lib/graphql/schema/types_migration.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # You can add this plugin to your schema to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Subset}
+    # handle `.visible?` differently in your schema.
+    #
+    # This plugin runs the same method on both implementations and raises an error when the results diverge.
+    #
+    # To fix the error, modify your schema so that both implementations return the same thing.
+    # Or, open an issue on GitHub to discuss the difference.
+    #
+    # This plugin adds overhead to runtime and may cause unexpected crashes -- **don't** use it in production!
+    #
+    # This plugin adds two keys to `context` when running:
+    #
+    # - `types_migration_running: true`
+    # - For the {Warden} which it instantiates, it adds `types_migration_warden_running: true`.
+    #
+    # Use those keys to modify your `visible?` behavior as needed.
+    #
+    # Also, in a pinch, you can set `skip_types_migration_error: true` in context to turn off this plugin's behavior per-query.
+    # (In that case, it uses {Subset} directly.)
+    #
+    # @example Adding this plugin
+    #
+    #   if !Rails.env.production?
+    #     use GraphQL::Schema::TypesMigration
+    #   end
+    class TypesMigration < GraphQL::Schema::Subset
+      def self.use(schema)
+        schema.subset_class = self
+      end
+
+      class RuntimeTypesMismatchError < GraphQL::Error
+        def initialize(method_called, warden_result, subset_result, method_args)
+          super(<<~ERR)
+            Mismatch in types for `##{method_called}(#{method_args.map(&:inspect).join(", ")})`:
+
+            #{compare_results(warden_result, subset_result)}
+
+            Update your `.visible?` implementation to make these implementations return the same value.
+
+            See: https://graphql-ruby.org/authorization/visibility_migration.html
+          ERR
+        end
+
+        private
+        def compare_results(warden_result, subset_result)
+          if warden_result.is_a?(Array) && subset_result.is_a?(Array)
+            all_results = warden_result | subset_result
+            all_results.sort_by!(&:graphql_name)
+
+            entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"}
+            width = entries_text.map(&:size).max
+            yes = "    ✔   "
+            no =  "        "
+            res = "".dup
+            res << "#{"Result".center(width)} Warden  Subset \n"
+            all_results.each_with_index do |entry, idx|
+              res << "#{entries_text[idx].ljust(width)}#{warden_result.include?(entry) ? yes : no}#{subset_result.include?(entry) ? yes : no}\n"
+            end
+            res << "\n"
+          else
+            "- Warden returned: #{humanize(warden_result)}\n\n- Subset returned: #{humanize(subset_result)}"
+          end
+        end
+        def humanize(val)
+          case val
+          when Array
+            "#{val.size}: #{val.map { |v| humanize(v) }.sort.inspect}"
+          when Module
+            if val.respond_to?(:graphql_name)
+              "#{val.graphql_name} (#{val.inspect})"
+            else
+              val.inspect
+            end
+          else
+            val.inspect
+          end
+        end
+      end
+
+      def initialize(context:, schema:)
+        @skip_error = context[:skip_types_migration_error]
+        context[:types_migration_running] = true
+        @subset_types = GraphQL::Schema::Subset.new(context: context, schema: schema)
+        if !@skip_error
+          warden_ctx_vals = context.to_h.dup
+          warden_ctx_vals[:types_migration_warden_running] = true
+          if defined?(schema::WardenCompatSchema)
+            warden_schema = schema::WardenCompatSchema
+          else
+            warden_schema = Class.new(schema)
+            warden_schema.use_schema_subset = false
+            # TODO public API
+            warden_schema.send(:add_type_and_traverse, [warden_schema.query, warden_schema.mutation, warden_schema.subscription].compact, root: true)
+            warden_schema.send(:add_type_and_traverse, warden_schema.directives.values + warden_schema.orphan_types, root: false)
+          end
+          warden_ctx = GraphQL::Query::Context.new(query: context.query, values: warden_ctx_vals)
+          example_warden = GraphQL::Schema::Warden.new(schema: warden_schema, context: warden_ctx)
+          @warden_types = example_warden.schema_subset
+          warden_ctx.warden = example_warden
+          warden_ctx.types = @warden_types
+        end
+      end
+
+      def loaded_types
+        @subset_types.loaded_types
+      end
+
+      PUBLIC_SUBSET_METHODS = [
+        :enum_values,
+        :interfaces,
+        :all_types,
+        :fields,
+        :loadable?,
+        :type,
+        :arguments,
+        :argument,
+        :directive_exists?,
+        :directives,
+        :field,
+        :query_root,
+        :mutation_root,
+        :possible_types,
+        :subscription_root,
+        :reachable_type?
+      ]
+
+      PUBLIC_SUBSET_METHODS.each do |subset_method|
+        define_method(subset_method) do |*args|
+          call_method_and_compare(subset_method, args)
+        end
+      end
+
+      def call_method_and_compare(method, args)
+        res_1 = @subset_types.public_send(method, *args)
+        if @skip_error
+          return res_1
+        end
+
+        res_2 = @warden_types.public_send(method, *args)
+        normalized_res_1 = res_1.is_a?(Array) ? Set.new(res_1) : res_1
+        normalized_res_2 = res_2.is_a?(Array) ? Set.new(res_2) : res_2
+        if !equivalent_schema_members?(normalized_res_1, normalized_res_2)
+          # Raise the errors with the orignally returned values:
+          err = RuntimeTypesMismatchError.new(method, res_2, res_1, args)
+          raise err
+        else
+          res_1
+        end
+      end
+
+      def equivalent_schema_members?(member1, member2)
+        if member1.class != member2.class
+          return false
+        end
+
+        case member1
+        when Set
+          member1_array = member1.to_a.sort_by(&:graphql_name)
+          member2_array = member2.to_a.sort_by(&:graphql_name)
+          member1_array.each_with_index do |inner_member1, idx|
+            inner_member2 = member2_array[idx]
+            equivalent_schema_members?(inner_member1, inner_member2)
+          end
+        when GraphQL::Schema::Field
+          member1.ensure_loaded
+          member2.ensure_loaded
+          if member1.introspection? && member2.introspection?
+            member1.inspect == member2.inspect
+          else
+            member1 == member2
+          end
+        when Module
+          if member1.introspection? && member2.introspection?
+            member1.graphql_name == member2.graphql_name
+          else
+            member1 == member2
+          end
+        else
+          member1 == member2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# 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)
+          return EMPTY_ARRAY if permitted_empty_value?(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,48 +430,62 @@ module GraphQL
         end
       end
 
-      def new_connections?
-        !!connections
-      end
-
-      def query(new_query_object = nil)
-        if new_query_object
+      def query(new_query_object = nil, &lazy_load_block)
+        if new_query_object || block_given?
           if @query_object
-            raise GraphQL::Error, "Second definition of `query(...)` (#{new_query_object.inspect}) is invalid, already configured with #{@query_object.inspect}"
+            dup_defn = new_query_object || yield
+            raise GraphQL::Error, "Second definition of `query(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@query_object.inspect}"
+          elsif use_schema_subset?
+            @query_object = block_given? ? lazy_load_block : new_query_object
           else
-            @query_object = new_query_object
-            add_type_and_traverse(new_query_object, root: true)
-            nil
+            @query_object = new_query_object || lazy_load_block.call
+            add_type_and_traverse(@query_object, root: true)
           end
+          nil
+        elsif @query_object.is_a?(Proc)
+          @query_object = @query_object.call
         else
           @query_object || find_inherited_value(:query)
         end
       end
 
-      def mutation(new_mutation_object = nil)
-        if new_mutation_object
+      def mutation(new_mutation_object = nil, &lazy_load_block)
+        if new_mutation_object || block_given?
           if @mutation_object
-            raise GraphQL::Error, "Second definition of `mutation(...)` (#{new_mutation_object.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+            dup_defn = new_mutation_object || yield
+            raise GraphQL::Error, "Second definition of `mutation(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@mutation_object.inspect}"
+          elsif use_schema_subset?
+            @mutation_object = block_given? ? lazy_load_block : new_mutation_object
           else
-            @mutation_object = new_mutation_object
-            add_type_and_traverse(new_mutation_object, root: true)
-            nil
+            @mutation_object = new_mutation_object || lazy_load_block.call
+            add_type_and_traverse(@mutation_object, root: true)
           end
+          nil
+        elsif @mutation_object.is_a?(Proc)
+          @mutation_object = @mutation_object.call
         else
           @mutation_object || find_inherited_value(:mutation)
         end
       end
 
-      def subscription(new_subscription_object = nil)
-        if new_subscription_object
+      def subscription(new_subscription_object = nil, &lazy_load_block)
+        if new_subscription_object || block_given?
           if @subscription_object
-            raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+            dup_defn = new_subscription_object || yield
+            raise GraphQL::Error, "Second definition of `subscription(...)` (#{dup_defn.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
+          elsif use_schema_subset?
+            @subscription_object = block_given? ? lazy_load_block : new_subscription_object
+            add_subscription_extension_if_necessary
           else
-            @subscription_object = new_subscription_object
+            @subscription_object = new_subscription_object || lazy_load_block.call
             add_subscription_extension_if_necessary
-            add_type_and_traverse(new_subscription_object, root: true)
-            nil
+            add_type_and_traverse(@subscription_object, root: true)
           end
+          nil
+        elsif @subscription_object.is_a?(Proc)
+          @subscription_object = @subscription_object.call
+          add_subscription_extension_if_necessary
+          @subscription_object
         else
           @subscription_object || find_inherited_value(:subscription)
         end
@@ -482,7 +507,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 +526,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 +631,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 +826,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 +934,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 +1100,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 +1193,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
@@ -1336,7 +1391,8 @@ module GraphQL
 
       # @api private
       def add_subscription_extension_if_necessary
-        if !defined?(@subscription_extension_added) && subscription && self.subscriptions
+        # TODO: when there's a proper API for extending root types, migrat this to use it.
+        if !defined?(@subscription_extension_added) && @subscription_object.is_a?(Class) && self.subscriptions
           @subscription_extension_added = true
           subscription.all_field_definitions.each do |field|
             if !field.extensions.any? { |ext| ext.is_a?(Subscriptions::DefaultSubscriptionResolveExtension) }
@@ -1485,7 +1541,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 +1557,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