graphql 2.5.9 → 2.5.26

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

@@ -8,6 +8,13 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
+      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # skip validation in this case instead.
+      #
+      # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
+      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      #
       # @example Require exactly one of these arguments
       #
       #   field :update_amount, IngredientAmount, null: false do
@@ -37,15 +44,17 @@ module GraphQL
       class RequiredValidator < Validator
         # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
         # @param argument [Symbol] An argument that is required for this field
+        # @param allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
+        def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
-            [argument]
+            [ argument ]
           else
             raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
           end
+          @allow_all_hidden = allow_all_hidden.nil? ? !!argument : allow_all_hidden
           @message = message
           super(**default_options)
         end
@@ -54,10 +63,17 @@ module GraphQL
           fully_matched_conditions = 0
           partially_matched_conditions = 0
 
+          visible_keywords = context.types.arguments(@validated).map(&:keyword)
+          no_visible_conditions = true
+
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
+                if no_visible_conditions && visible_keywords.include?(one_of_condition)
+                  no_visible_conditions = false
+                end
+
                 if value.key?(one_of_condition)
                   fully_matched_conditions += 1
                 end
@@ -66,6 +82,9 @@ module GraphQL
                 full_match = true
 
                 one_of_condition.each do |k|
+                  if no_visible_conditions && visible_keywords.include?(k)
+                    no_visible_conditions = false
+                  end
                   if value.key?(k)
                     any_match = true
                   else
@@ -88,6 +107,18 @@ module GraphQL
             end
           end
 
+          if no_visible_conditions
+            if @allow_all_hidden
+              return nil
+            else
+              raise GraphQL::Error, <<~ERR
+                #{@validated.path} validates `required: ...` but all required arguments were hidden.
+
+                Update your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`
+              ERR
+            end
+          end
+
           if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
@@ -96,17 +127,26 @@ 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_graphql_name(argument_definitions, arg) }
+              names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else
               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(", ")}."
@@ -115,7 +155,7 @@ module GraphQL
 
         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,40 @@ 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
+          @cached_field_result.default_proc = nil
+          @cached_field_result.each { |_, h| h.default_proc = nil }
+          @cached_type_result.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 = []
@@ -95,6 +125,14 @@ module GraphQL
           end.compare_by_identity
 
           @loadable_possible_types = Hash.new { |h, union_type| h[union_type] = union_type.possible_types }.compare_by_identity
+
+          # Combined cache for field(owner, field_name) — avoids repeated kind check + parent lookup + visibility check
+          @cached_field_result = Hash.new { |h, owner|
+            h[owner] = Hash.new { |h2, field_name| h2[field_name] = compute_field(owner, field_name) }
+          }.compare_by_identity
+
+          # Cache for type(type_name) — avoids repeated get_type + visibility + referenced? checks
+          @cached_type_result = Hash.new { |h, type_name| h[type_name] = compute_type(type_name) }
         end
 
         def field_on_visible_interface?(field, owner)
@@ -122,58 +160,11 @@ module GraphQL
         end
 
         def type(type_name)
-          t = @schema.visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
-          if t
-            if t.is_a?(Array)
-              vis_t = nil
-              t.each do |t_defn|
-                if @cached_visible[t_defn] && referenced?(t_defn)
-                  if vis_t.nil?
-                    vis_t = t_defn
-                  else
-                    raise_duplicate_definition(vis_t, t_defn)
-                  end
-                end
-              end
-              vis_t
-            else
-              if t && @cached_visible[t] && referenced?(t)
-                t
-              else
-                nil
-              end
-            end
-          end
+          @cached_type_result[type_name]
         end
 
         def field(owner, field_name)
-          f = if owner.kind.fields? && (field = @cached_parent_fields[owner][field_name])
-            field
-          elsif owner == query_root && (entry_point_field = @schema.introspection_system.entry_point(name: field_name))
-            entry_point_field
-          elsif (dynamic_field = @schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field
-          else
-            nil
-          end
-          if f.is_a?(Array)
-            visible_f = nil
-            f.each do |f_defn|
-              if @cached_visible_fields[owner][f_defn]
-
-                if visible_f.nil?
-                  visible_f = f_defn
-                else
-                  raise_duplicate_definition(visible_f, f_defn)
-                end
-              end
-            end
-            visible_f&.ensure_loaded
-          elsif f && @cached_visible_fields[owner][f.ensure_loaded]
-            f
-          else
-            nil
-          end
+          @cached_field_result[owner][field_name]
         end
 
         def fields(owner)
@@ -250,8 +241,8 @@ 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
 
@@ -276,8 +267,99 @@ module GraphQL
           @cached_visible[enum_value]
         end
 
+        def preload
+          load_all_types
+          @all_types.each do |type_name, type_defn|
+            type(type_name)
+            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 compute_type(type_name)
+          t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+          if t
+            if t.is_a?(Array)
+              vis_t = nil
+              t.each do |t_defn|
+                if @cached_visible[t_defn] && referenced?(t_defn)
+                  if vis_t.nil?
+                    vis_t = t_defn
+                  else
+                    raise_duplicate_definition(vis_t, t_defn)
+                  end
+                end
+              end
+              vis_t
+            else
+              if t && @cached_visible[t] && referenced?(t)
+                t
+              else
+                nil
+              end
+            end
+          end
+        end
+
+        def compute_field(owner, field_name)
+          f = if owner.kind.fields? && (field = @cached_parent_fields[owner][field_name])
+            field
+          elsif owner == query_root && (entry_point_field = @schema.introspection_system.entry_point(name: field_name))
+            entry_point_field
+          elsif (dynamic_field = @schema.introspection_system.dynamic_field(name: field_name))
+            dynamic_field
+          else
+            nil
+          end
+          if f.is_a?(Array)
+            visible_f = nil
+            f.each do |f_defn|
+              if @cached_visible_fields[owner][f_defn]
+                if visible_f.nil?
+                  visible_f = f_defn
+                else
+                  raise_duplicate_definition(visible_f, f_defn)
+                end
+              end
+            end
+            visible_f&.ensure_loaded
+          elsif f && @cached_visible_fields[owner][f.ensure_loaded]
+            f
+          else
+            nil
+          end
+        end
+
         def non_duplicate_items(definitions, visibility_cache)
           non_dups = []
           names = Set.new
@@ -322,7 +404,7 @@ module GraphQL
         end
 
         def referenced?(type_defn)
-          @schema.visibility.all_references[type_defn].any? do |ref|
+          @visibility.all_references[type_defn].any? do |ref|
             case ref
             when GraphQL::Schema::Argument
               @cached_visible_arguments[ref.owner][ref]
@@ -340,9 +422,11 @@ module GraphQL
           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

@@ -10,17 +10,14 @@ module GraphQL
     class Visibility
       # @param schema [Class<GraphQL::Schema>]
       # @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 preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
       # @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.env) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging?) : 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
 
@@ -153,12 +163,12 @@ module GraphQL
           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)
+            @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)
+              @schema.visibility_profile_class.new(context: context, schema: @schema, visibility: self)
             end
           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."
@@ -168,7 +178,7 @@ module GraphQL
         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
 
@@ -181,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: @schema.null_context, schema: @schema, visibility: self)
       end
 
       private
@@ -202,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
@@ -227,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
@@ -276,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/wrapper.rb

@@ -13,7 +13,13 @@ module GraphQL
       end
 
       def unwrap
-        @of_type.unwrap
+        @unwrapped ||= @of_type.unwrap
+      end
+
+      def freeze
+        unwrap
+        to_type_signature
+        super
       end
 
       def ==(other)