graphql 2.4.0 → 2.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26e43b0bc48317698ed17f8a11498c19a7a4a0df9d33fdc9785edc47ae1147b6
-  data.tar.gz: 74402e930ebe03a451bc2bdb82285642aeeba7222ab491dd9329400fc852eb41
+  metadata.gz: bbf9779d0fbc1da481a481d987489b980818c5ea6afb352f4e65f0654ea14163
+  data.tar.gz: 91528aabb657b8602c7f3143b6a9dc3a770a336f6a31af0f89fce1c27e5e00a0
 SHA512:
-  metadata.gz: f1d97c4397ca8410f6b62c3ea2de9a0a4b18ca610adcb92de9676c5377b00a071cbff4fbd0396760eea9ab359e4b0b8cdfff1630c9fa83de51cfd31b0b96307f
-  data.tar.gz: d9250a9ad1d57f40e7b0151484f77a66e11a361f8b0f50938f42219eb8322a9b4dc59c59102f4b49f62a28e90f03b8f9e0cf5b2799b5fd5080dbcf443cebac15
+  metadata.gz: c73cedf9cd1fc6ab4d91f026dfe627cb1490d5888d1252f591b944359e1f537a479c5d7f7ceed691ddd79883ae1ba027dfb952e969d14617e6a19becee792aa6
+  data.tar.gz: 4d429bb74350c9fbbaa0e33498ccb193acfa6691f62342b38923965e69bc23bb377e6ade8a56b8f5d5c785ea24a2f6e04a47a8384000a45140d320e7461c6832

data/lib/graphql/query/null_context.rb

@@ -18,17 +18,15 @@ module GraphQL
       extend Forwardable
 
       attr_reader :schema, :query, :warden, :dataloader
-      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?
+      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?, :to_h
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
-      end
-
-      def types
-        @types ||= Schema::Warden::VisibilityProfile.new(@warden)
+        @types = @warden.visibility_profile
+        freeze
       end
     end
   end

data/lib/graphql/schema/enum.rb

@@ -86,10 +86,24 @@ module GraphQL
         def enum_values(context = GraphQL::Query::NullContext.instance)
           inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
           visible_values = []
-          warden = Warden.from_context(context)
+          types = Warden.types_from_context(context)
           own_values.each do |key, values_entry|
-            if (v = Warden.visible_entry?(:visible_enum_value?, values_entry, context, warden))
-              visible_values << v
+            visible_value = nil
+            if values_entry.is_a?(Array)
+              values_entry.each do |v|
+                if types.visible_enum_value?(v, context)
+                  if visible_value.nil?
+                    visible_value = v
+                    visible_values << v
+                  else
+                    raise DuplicateNamesError.new(
+                      duplicated_name: v.path, duplicated_definition_1: visible_value.inspect, duplicated_definition_2: v.inspect
+                    )
+                  end
+                end
+              end
+            elsif types.visible_enum_value?(values_entry, context)
+              visible_values << values_entry
             end
           end
 

data/lib/graphql/schema/enum_value.rb

@@ -74,7 +74,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
+        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}#{deprecation_reason ? " @deprecation_reason=#{deprecation_reason.inspect}" : ""}>"
       end
 
       def visible?(_ctx); true; end

data/lib/graphql/schema/visibility/migration.rb

@@ -122,7 +122,8 @@ module GraphQL
           :mutation_root,
           :possible_types,
           :subscription_root,
-          :reachable_type?
+          :reachable_type?,
+          :visible_enum_value?,
         ]
 
         PUBLIC_PROFILE_METHODS.each do |profile_method|

data/lib/graphql/schema/visibility/profile.rb

@@ -22,9 +22,9 @@ module GraphQL
           end
         end
 
-        def self.pass_thru(context:, schema:)
-          profile = self.new(context: context, schema: schema)
-          profile.instance_variable_set(:@cached_visible, Hash.new { |h,k| h[k] = true })
+        def self.null_profile(context:, schema:)
+          profile = self.new(name: "NullProfile", context: context, schema: schema)
+          profile.instance_variable_set(:@cached_visible, Hash.new { |k, v| k[v] = true }.compare_by_identity)
           profile
         end
 
@@ -123,7 +123,7 @@ module GraphQL
           end.compare_by_identity
 
           @cached_enum_values = Hash.new do |h, enum_t|
-            values = non_duplicate_items(enum_t.all_enum_value_definitions, @cached_visible)
+            values = non_duplicate_items(enum_t.enum_values(@context), @cached_visible)
             if values.size == 0
               raise GraphQL::Schema::Enum::MissingValuesError.new(enum_t)
             end
@@ -327,6 +327,10 @@ module GraphQL
           !!@all_types[name]
         end
 
+        def visible_enum_value?(enum_value, _ctx = nil)
+          @cached_visible[enum_value]
+        end
+
         private
 
         def add_if_visible(t)
@@ -400,7 +404,7 @@ module GraphQL
             end
           end
 
-          entry_point_types.compact! # TODO why is this necessary?!
+          entry_point_types.compact! # Root types might be nil
           entry_point_types.flatten! # handle multiple defns
           entry_point_types.each { |t| add_type(t, true) }
 

data/lib/graphql/schema/visibility.rb

@@ -21,11 +21,27 @@ module GraphQL
         if migration_errors
           schema.visibility_profile_class = Migration
         end
+        @preload = preload
         @profiles = profiles
         @cached_profiles = {}
         @dynamic = dynamic
         @migration_errors = migration_errors
         if preload
+          # Traverse the schema now (and in the *_configured hooks below)
+          # To make sure things are loaded during boot
+          @preloaded_types = Set.new
+          types_to_visit = [
+            @schema.query,
+            @schema.mutation,
+            @schema.subscription,
+            *@schema.introspection_system.types.values,
+            *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
+            *@schema.orphan_types,
+          ]
+          # Root types may have been nil:
+          types_to_visit.compact!
+          ensure_all_loaded(types_to_visit)
+
           profiles.each do |profile_name, example_ctx|
             example_ctx[:visibility_profile] = profile_name
             prof = profile_for(example_ctx, profile_name)
@@ -34,6 +50,45 @@ module GraphQL
         end
       end
 
+      # @api private
+      def query_configured(query_type)
+        if @preload
+          ensure_all_loaded([query_type])
+        end
+      end
+
+      # @api private
+      def mutation_configured(mutation_type)
+        if @preload
+          ensure_all_loaded([mutation_type])
+        end
+      end
+
+      # @api private
+      def subscription_configured(subscription_type)
+        if @preload
+          ensure_all_loaded([subscription_type])
+        end
+      end
+
+      # @api private
+      def orphan_types_configured(orphan_types)
+        if @preload
+          ensure_all_loaded(orphan_types)
+        end
+      end
+
+      # @api private
+      def introspection_system_configured(introspection_system)
+        if @preload
+          introspection_types = [
+            *@schema.introspection_system.types.values,
+            *@schema.introspection_system.entry_points.map { |ep| ep.type.unwrap },
+          ]
+          ensure_all_loaded(introspection_types)
+        end
+      end
+
       # Make another Visibility for `schema` based on this one
       # @return [Visibility]
       # @api private
@@ -70,6 +125,19 @@ module GraphQL
           @schema.visibility_profile_class.new(context: context, schema: @schema)
         end
       end
+
+      private
+
+      def ensure_all_loaded(types_to_visit)
+        while (type = types_to_visit.shift)
+          if type.kind.fields? && @preloaded_types.add?(type)
+            type.all_field_definitions.each do |field_defn|
+              field_defn.ensure_loaded
+              types_to_visit << field_defn.type.unwrap
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/warden.rb

@@ -19,6 +19,13 @@ module GraphQL
         PassThruWarden
       end
 
+      def self.types_from_context(context)
+        context.types || PassThruWarden
+      rescue NoMethodError
+        # this might be a hash which won't respond to #warden
+        PassThruWarden
+      end
+
       def self.use(schema)
         # no-op
       end
@@ -80,24 +87,17 @@ module GraphQL
         # No-op, but for compatibility:
         attr_writer :skip_warning
 
-        # @api private
-        module NullVisibilityProfile
-          def self.new(context:, schema:)
-            NullWarden.new(context: context, schema: schema).visibility_profile
-          end
-        end
-
         attr_reader :visibility_profile
 
         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
-        def visible_enum_value?(enum_value, _ctx = nil); true; end
+        def visible_enum_value?(enum_value, _ctx = nil); enum_value.visible?(Query::NullContext.instance); end
         def visible_type_membership?(type_membership, _ctx = nil); true; end
         def interface_type_memberships(obj_type, _ctx = nil); obj_type.interface_type_memberships; end
         def get_type(type_name); @schema.get_type(type_name, Query::NullContext.instance, false); end # rubocop:disable Development/ContextIsPassedCop
         def arguments(argument_owner, ctx = nil); argument_owner.all_argument_definitions; end
-        def enum_values(enum_defn); enum_defn.enum_values; end # rubocop:disable Development/ContextIsPassedCop
+        def enum_values(enum_defn); enum_defn.enum_values(Query::NullContext.instance); end # rubocop:disable Development/ContextIsPassedCop
         def get_argument(parent_type, argument_name); parent_type.get_argument(argument_name); end # rubocop:disable Development/ContextIsPassedCop
         def types; @schema.types; end # rubocop:disable Development/ContextIsPassedCop
         def root_type_for_operation(op_name); @schema.root_type_for_operation(op_name); end
@@ -183,6 +183,10 @@ module GraphQL
         def reachable_type?(type_name)
           !!@warden.reachable_type?(type_name)
         end
+
+        def visible_enum_value?(enum_value, ctx = nil)
+          @warden.visible_enum_value?(enum_value, ctx)
+        end
       end
 
       # @param context [GraphQL::Query::Context]

data/lib/graphql/schema.rb

@@ -445,7 +445,12 @@ module GraphQL
             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_visibility_profile?
-            @query_object = block_given? ? lazy_load_block : new_query_object
+            if block_given?
+              @query_object = lazy_load_block
+            else
+              @query_object = new_query_object
+              self.visibility.query_configured(@query_object)
+            end
           else
             @query_object = new_query_object || lazy_load_block.call
             add_type_and_traverse(@query_object, root: true)
@@ -453,6 +458,8 @@ module GraphQL
           nil
         elsif @query_object.is_a?(Proc)
           @query_object = @query_object.call
+          self.visibility&.query_configured(@query_object)
+          @query_object
         else
           @query_object || find_inherited_value(:query)
         end
@@ -472,7 +479,12 @@ module GraphQL
             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_visibility_profile?
-            @mutation_object = block_given? ? lazy_load_block : new_mutation_object
+            if block_given?
+              @mutation_object = lazy_load_block
+            else
+              @mutation_object = new_mutation_object
+              self.visibility.mutation_configured(@mutation_object)
+            end
           else
             @mutation_object = new_mutation_object || lazy_load_block.call
             add_type_and_traverse(@mutation_object, root: true)
@@ -480,6 +492,8 @@ module GraphQL
           nil
         elsif @mutation_object.is_a?(Proc)
           @mutation_object = @mutation_object.call
+          self.visibility&.mutation_configured(@query_object)
+          @mutation_object
         else
           @mutation_object || find_inherited_value(:mutation)
         end
@@ -499,7 +513,12 @@ module GraphQL
             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_visibility_profile?
-            @subscription_object = block_given? ? lazy_load_block : new_subscription_object
+            if block_given?
+              @subscription_object = lazy_load_block
+            else
+              @subscription_object = new_subscription_object
+              self.visibility.subscription_configured(@subscription_object)
+            end
             add_subscription_extension_if_necessary
           else
             @subscription_object = new_subscription_object || lazy_load_block.call
@@ -510,6 +529,7 @@ module GraphQL
         elsif @subscription_object.is_a?(Proc)
           @subscription_object = @subscription_object.call
           add_subscription_extension_if_necessary
+          self.visibility.subscription_configured(@subscription_object)
           @subscription_object
         else
           @subscription_object || find_inherited_value(:subscription)
@@ -695,20 +715,27 @@ module GraphQL
         type.fields(context)
       end
 
+      # Pass a custom introspection module here to use it for this schema.
+      # @param new_introspection_namespace [Module] If given, use this module for custom introspection on the schema
+      # @return [Module, nil] The configured namespace, if there is one
       def introspection(new_introspection_namespace = nil)
         if new_introspection_namespace
           @introspection = new_introspection_namespace
           # reset this cached value:
           @introspection_system = nil
+          introspection_system
+          @introspection
         else
           @introspection || find_inherited_value(:introspection)
         end
       end
 
+      # @return [Schema::IntrospectionSystem] Based on {introspection}
       def introspection_system
         if !@introspection_system
           @introspection_system = Schema::IntrospectionSystem.new(self)
           @introspection_system.resolve_late_bindings
+          self.visibility&.introspection_system_configured(@introspection_system)
         end
         @introspection_system
       end
@@ -952,6 +979,13 @@ module GraphQL
         end
       end
 
+      # Tell the schema about these types so that they can be registered as implementations of interfaces in the schema.
+      #
+      # This method must be used when an object type is connected to the schema as an interface implementor but
+      # not as a return type of a field. In that case, if the object type isn't registered here, GraphQL-Ruby won't be able to find it.
+      #
+      # @param new_orphan_types [Array<Class<GraphQL::Schema::Object>>] Object types to register as implementations of interfaces in the schema.
+      # @return [Array<Class<GraphQL::Schema::Object>>] All previously-registered orphan types for this schema
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           new_orphan_types = new_orphan_types.flatten
@@ -968,6 +1002,7 @@ module GraphQL
           end
           add_type_and_traverse(new_orphan_types, root: false) unless use_visibility_profile?
           own_orphan_types.concat(new_orphan_types.flatten)
+          self.visibility&.orphan_types_configured(new_orphan_types)
         end
 
         inherited_ot = find_inherited_value(:orphan_types, nil)

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

@@ -14,7 +14,9 @@ module GraphQL
               node_name: parent_type.graphql_name
             ))
           else
-            message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{context.did_you_mean_suggestion(node.name, context.types.fields(parent_type).map(&:graphql_name))}"
+            possible_fields = possible_fields(context, parent_type)
+            suggestion = context.did_you_mean_suggestion(node.name, possible_fields)
+            message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{suggestion}"
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
               message,
               nodes: node,
@@ -26,6 +28,13 @@ module GraphQL
           super
         end
       end
+
+      private
+
+      def possible_fields(context, parent_type)
+        return EmptyObjects::EMPTY_ARRAY if parent_type.kind.leaf?
+        context.types.fields(parent_type).map(&:graphql_name)
+      end
     end
   end
 end

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

@@ -25,7 +25,7 @@ module GraphQL
       def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
-        elsif resolved_type.kind.scalar? && ast_node.selections.any?
+        elsif ast_node.selections.any? && resolved_type.kind.leaf?
           selection_strs = ast_node.selections.map do |n|
             case n
             when GraphQL::Language::Nodes::InlineFragment
@@ -38,7 +38,7 @@ module GraphQL
               raise "Invariant: unexpected selection node: #{n}"
             end
           end
-          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
+          "Selections can't be made on #{resolved_type.kind.name.sub("_", " ").downcase}s (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else

data/lib/graphql/testing/helpers.rb

@@ -92,7 +92,7 @@ module GraphQL
           end
           graphql_result
         else
-          unfiltered_type = Schema::Visibility::Profile.pass_thru(schema: schema, context: context).type(type_name)
+          unfiltered_type = Schema::Visibility::Profile.null_profile(schema: schema, context: context).type(type_name)
           if unfiltered_type
             raise TypeNotVisibleError.new(type_name: type_name)
           else

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.4.0"
+  VERSION = "2.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.2
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-31 00:00:00.000000000 Z
+date: 2024-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64