graphql 1.12.23 → 1.13.3

data/lib/graphql/schema/object.rb

@@ -7,6 +7,7 @@ module GraphQL
     class Object < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasInterfaces
 
       # @return [Object] the application object this type is wrapping
       attr_reader :object
@@ -103,84 +104,16 @@ module GraphQL
           super
         end
 
-        def implements(*new_interfaces, **options)
-          new_memberships = []
-          new_interfaces.each do |int|
-            if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
-              end
-
-              new_memberships << int.type_membership_class.new(int, self, **options)
-
-              # Include the methods here,
-              # `.fields` will use the inheritance chain
-              # to find inherited fields
-              include(int)
-            elsif int.is_a?(GraphQL::InterfaceType)
-              new_memberships << int.type_membership_class.new(int, self, **options)
-            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
-              if options.any?
-                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
-              end
-              new_memberships << int
-            else
-              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
-            end
-          end
-
-          # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
-          own_interface_type_memberships.reject! { |old_i_m|
-            old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
-            old_name = Schema::Member::BuildType.to_type_name(old_int_type)
-
-            new_memberships.any? { |new_i_m|
-              new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
-              new_name = Schema::Member::BuildType.to_type_name(new_int_type)
-
-              new_name == old_name
-            }
-          }
-          own_interface_type_memberships.concat(new_memberships)
-        end
-
-        def own_interface_type_memberships
-          @own_interface_type_memberships ||= []
-        end
-
-        def interface_type_memberships
-          own_interface_type_memberships + (superclass.respond_to?(:interface_type_memberships) ? superclass.interface_type_memberships : [])
-        end
-
-        # param context [Query::Context] If omitted, skip filtering.
-        def interfaces(context = GraphQL::Query::NullContext)
-          visible_interfaces = []
-          unfiltered = context == GraphQL::Query::NullContext
-          own_interface_type_memberships.each do |type_membership|
-            # During initialization, `type_memberships` can hold late-bound types
-            case type_membership
-            when String, Schema::LateBoundType
-              visible_interfaces << type_membership
-            when Schema::TypeMembership
-              if unfiltered || type_membership.visible?(context)
-                visible_interfaces << type_membership.abstract_type
-              end
-            else
-              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
-            end
-          end
-          visible_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces(context) : [])
-        end
-
         # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
         # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
-        def fields
+        def fields(context = GraphQL::Query::NullContext)
           all_fields = super
+          # This adds fields from legacy-style interfaces only.
+          # Multi-fields are not supported here.
           interfaces.each do |int|
-            # Include legacy-style interfaces, too
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
-              int.fields.each do |name, legacy_field|
+              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
                 int_f[name] = field_class.from_options(name, field: legacy_field)
               end
               all_fields = int_f.merge(all_fields)
@@ -189,6 +122,8 @@ module GraphQL
           all_fields
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
@@ -198,9 +133,9 @@ module GraphQL
           obj_type.introspection = introspection
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node
-          fields.each do |field_name, field_inst|
-            field_defn = field_inst.to_graphql
-            obj_type.fields[field_defn.name] = field_defn
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
+            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 
           obj_type.metadata[:type_class] = self

data/lib/graphql/schema/printer.rb

@@ -56,7 +56,7 @@ module GraphQL
       def self.print_introspection_schema
         query_root = Class.new(GraphQL::Schema::Object) do
           graphql_name "Root"
-          field :throwaway_field, String, null: true
+          field :throwaway_field, String
         end
         schema = Class.new(GraphQL::Schema) { query(query_root) }
 

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -22,7 +22,7 @@ module GraphQL
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
       # The payload should always include this field
-      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
       null(true)
 
@@ -81,6 +81,31 @@ module GraphQL
       end
 
       class << self
+
+        # Also apply this argument to the input type:
+        def argument(*args, **kwargs, &block)
+          it = input_type # make sure any inherited arguments are already added to it
+          arg = super
+
+          # This definition might be overriding something inherited;
+          # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
+          prev_args = it.own_arguments[arg.graphql_name]
+          case prev_args
+          when GraphQL::Schema::Argument
+            if prev_args.owner != self
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          when Array
+            prev_args.reject! { |a| a.owner != self }
+            if prev_args.empty?
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          end
+
+          it.add_argument(arg)
+          arg
+        end
+
         # The base class for generated input object types
         # @param new_class [Class] The base class to use for generating input object definitions
         # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
@@ -115,20 +140,29 @@ module GraphQL
         # To customize how input objects are generated, override this method
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
-          mutation_args = arguments
+          mutation_args = all_argument_definitions
           mutation_name = graphql_name
           mutation_class = self
           Class.new(input_object_class) do
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            mutation_args.each do |_name, arg|
+            # these might be inherited:
+            mutation_args.each do |arg|
               add_argument(arg)
             end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
           end
         end
       end
+
+      private
+
+      def authorize_arguments(args, values)
+        # remove the `input` wrapper to match values
+        input_args = args["input"].type.unwrap.arguments(context)
+        super(input_args, values)
+      end
     end
   end
 end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -38,6 +38,9 @@ module GraphQL
         # @return [Class]
         def object_class(new_class = nil)
           if new_class
+            if defined?(@payload_type)
+              raise "Can't configure `object_class(...)` after the payload type has already been initialized. Move this configuration higher up the class definition."
+            end
             @object_class = new_class
           else
             @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
@@ -46,6 +49,28 @@ module GraphQL
 
         NO_INTERFACES = [].freeze
 
+        def field(*args, **kwargs, &block)
+          pt = payload_type # make sure it's initialized with any inherited fields
+          field_defn = super
+
+          # Remove any inherited fields to avoid false conflicts at runtime
+          prev_fields = pt.own_fields[field_defn.graphql_name]
+          case prev_fields
+          when GraphQL::Schema::Field
+            if prev_fields.owner != self
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          when Array
+            prev_fields.reject! { |f| f.owner != self }
+            if prev_fields.empty?
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          end
+
+          pt.add_field(field_defn, method_conflict_warning: false)
+          field_defn
+        end
+
         private
 
         # Build a subclass of {.object_class} based on `self`.
@@ -53,11 +78,11 @@ module GraphQL
         # Override this hook to customize return type generation.
         def generate_payload_type
           resolver_name = graphql_name
-          resolver_fields = fields
+          resolver_fields = all_field_definitions
           Class.new(object_class) do
             graphql_name("#{resolver_name}Payload")
             description("Autogenerated return type of #{resolver_name}")
-            resolver_fields.each do |name, f|
+            resolver_fields.each do |f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
               # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.

data/lib/graphql/schema/resolver.rb

@@ -37,7 +37,7 @@ module GraphQL
         @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
-        self.class.arguments.each do |name, arg|
+        self.class.arguments(context).each do |name, arg|
           @arguments_by_keyword[arg.keyword] = arg
         end
         @prepared_arguments = nil
@@ -145,19 +145,9 @@ module GraphQL
       # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
       # @return [Boolean, early_return_data] If `false`, execution will stop (and `early_return_data` will be returned instead, if present.)
       def authorized?(**inputs)
-        self.class.arguments.each_value do |argument|
-          arg_keyword = argument.keyword
-          if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
-            arg_auth, err = argument.authorized?(self, arg_value, context)
-            if !arg_auth
-              return arg_auth, err
-            else
-              true
-            end
-          else
-            true
-          end
-        end
+        arg_owner = @field # || self.class
+        args = arg_owner.arguments(context)
+        authorize_arguments(args, inputs)
       end
 
       # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
@@ -172,6 +162,22 @@ module GraphQL
 
       private
 
+      def authorize_arguments(args, inputs)
+        args.each_value do |argument|
+          arg_keyword = argument.keyword
+          if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
+            arg_auth, err = argument.authorized?(self, arg_value, context)
+            if !arg_auth
+              return arg_auth, err
+            else
+              true
+            end
+          else
+            true
+          end
+        end
+      end
+
       def load_arguments(args)
         prepared_args = {}
         prepare_lazies = []
@@ -199,8 +205,8 @@ module GraphQL
         end
       end
 
-      def get_argument(name)
-        self.class.get_argument(name)
+      def get_argument(name, context = GraphQL::Query::NullContext)
+        self.class.get_argument(name, context)
       end
 
       class << self
@@ -305,13 +311,27 @@ module GraphQL
         end
 
         def field_options
+
+          all_args = {}
+          all_argument_definitions.each do |arg|
+            if (prev_entry = all_args[arg.graphql_name])
+              if prev_entry.is_a?(Array)
+                prev_entry << arg
+              else
+                all_args[arg.graphql_name] = [prev_entry, arg]
+              end
+            else
+              all_args[arg.graphql_name] = arg
+            end
+          end
+
           field_opts = {
             type: type_expr,
             description: description,
             extras: extras,
             resolver_method: :resolve_with_support,
             resolver_class: self,
-            arguments: arguments,
+            arguments: all_args,
             null: null,
             complexity: complexity,
             broadcastable: broadcastable?,

data/lib/graphql/schema/scalar.rb

@@ -14,6 +14,8 @@ module GraphQL
           val
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::ScalarType.new
           type_defn.name = graphql_name

data/lib/graphql/schema/subscription.rb

@@ -103,10 +103,12 @@ module GraphQL
       # Call this method to provide a new subscription_scope; OR
       # call it without an argument to get the subscription_scope
       # @param new_scope [Symbol]
+      # @param optional [Boolean] If true, then don't require `scope:` to be provided to updates to this subscription.
       # @return [Symbol]
-      def self.subscription_scope(new_scope = READING_SCOPE)
+      def self.subscription_scope(new_scope = READING_SCOPE, optional: false)
         if new_scope != READING_SCOPE
           @subscription_scope = new_scope
+          @subscription_scope_optional = optional
         elsif defined?(@subscription_scope)
           @subscription_scope
         else
@@ -114,6 +116,14 @@ module GraphQL
         end
       end
 
+      def self.subscription_scope_optional?
+        if defined?(@subscription_scope_optional)
+          @subscription_scope_optional
+        else
+          find_inherited_value(:subscription_scope_optional, false)
+        end
+      end
+
       # This is called during initial subscription to get a "name" for this subscription.
       # Later, when `.trigger` is called, this will be called again to build another "name".
       # Any subscribers with matching topic will begin the update flow.

data/lib/graphql/schema/traversal.rb

@@ -173,7 +173,7 @@ Some late-bound types couldn't be resolved:
           end
         when Class
           if member.respond_to?(:graphql_definition)
-            graphql_member = member.graphql_definition
+            graphql_member = member.graphql_definition(silence_deprecation_warning: true)
             visit(schema, graphql_member, context_description)
           else
             raise GraphQL::Schema::InvalidTypeError.new("Unexpected traversal member: #{member} (#{member.class.name})")

data/lib/graphql/schema/type_expression.rb

@@ -11,7 +11,7 @@ module GraphQL
       def self.build_type(type_owner, ast_node)
         case ast_node
         when GraphQL::Language::Nodes::TypeName
-          type_owner.get_type(ast_node.name)
+          type_owner.get_type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
         when GraphQL::Language::Nodes::NonNullType
           ast_inner_type = ast_node.of_type
           inner_type = build_type(type_owner, ast_inner_type)

data/lib/graphql/schema/type_membership.rb

@@ -4,8 +4,6 @@ module GraphQL
   class Schema
     # This class joins an object type to an abstract type (interface or union) of which
     # it is a member.
-    #
-    # TODO: Not yet implemented for interfaces.
     class TypeMembership
       # @return [Class<GraphQL::Schema::Object>]
       attr_accessor :object_type
@@ -26,9 +24,25 @@ module GraphQL
       end
 
       # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
-      def visible?(_ctx)
-        true
+      def visible?(ctx)
+        warden = Warden.from_context(ctx)
+        (@object_type.respond_to?(:visible?) ? warden.visible_type?(@object_type, ctx) : true) &&
+          (@abstract_type.respond_to?(:visible?) ? warden.visible_type?(@abstract_type, ctx) : true)
       end
+
+      def graphql_name
+        "#{@object_type.graphql_name}.#{@abstract_type.kind.interface? ? "implements" : "belongsTo" }.#{@abstract_type.graphql_name}"
+      end
+
+      def path
+        graphql_name
+      end
+
+      def inspect
+        "#<#{self.class} #{@object_type.inspect} => #{@abstract_type.inspect}>"
+      end
+
+      alias :type_class :itself
     end
   end
 end

data/lib/graphql/schema/union.rb

@@ -19,8 +19,9 @@ module GraphQL
             end
           else
             visible_types = []
+            warden = Warden.from_context(context)
             type_memberships.each do |type_membership|
-              if type_membership.visible?(context)
+              if warden.visible_type_membership?(type_membership, context)
                 visible_types << type_membership.object_type
               end
             end
@@ -28,6 +29,12 @@ module GraphQL
           end
         end
 
+        def all_possible_types
+          type_memberships.map(&:object_type)
+        end
+
+        prepend GraphQL::Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         def to_graphql
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name

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

@@ -18,10 +18,6 @@ module GraphQL
       #   # It's pretty hard to come up with a legitimate use case for `without:`
       #
       class FormatValidator < Validator
-        if !String.method_defined?(:match?)
-          using GraphQL::StringMatchBackport
-        end
-
         # @param with [RegExp, nil]
         # @param without [Regexp, nil]
         # @param message [String]

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     class Validator

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

@@ -14,7 +14,7 @@ module GraphQL
       #     argument :ingredient_id, ID, required: true
       #     argument :cups, Integer, required: false
       #     argument :tablespoons, Integer, required: false
-      #     argument :teaspoons, Integer, required: true
+      #     argument :teaspoons, Integer, required: false
       #     validates required: { one_of: [:cups, :tablespoons, :teaspoons] }
       #   end
       #
@@ -28,11 +28,23 @@ module GraphQL
       #    validates required: { one_of: [:node_id, [:object_type, :object_id]] }
       #  end
       #
+      # @example require _some_ value for an argument, even if it's null
+      #   field :update_settings, AccountSettings do
+      #     # `required: :nullable` means this argument must be given, but may be `null`
+      #     argument :age, Integer, required: :nullable
+      #   end
+      #
       class RequiredValidator < Validator
         # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
         # @param message [String]
-        def initialize(one_of:, message: "%{validated} has the wrong arguments", **default_options)
-          @one_of = one_of
+        def initialize(one_of: nil, argument: nil, message: "%{validated} has the wrong arguments", **default_options)
+          @one_of = if one_of
+            one_of
+          elsif argument
+            [argument]
+          else
+            raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
+          end
           @message = message
           super(**default_options)
         end
@@ -40,19 +52,21 @@ module GraphQL
         def validate(_object, _context, value)
           matched_conditions = 0
 
-          @one_of.each do |one_of_condition|
-            case one_of_condition
-            when Symbol
-              if value.key?(one_of_condition)
-                matched_conditions += 1
-              end
-            when Array
-              if one_of_condition.all? { |k| value.key?(k) }
-                matched_conditions += 1
-                break
+          if !value.nil?
+            @one_of.each do |one_of_condition|
+              case one_of_condition
+              when Symbol
+                if value.key?(one_of_condition)
+                  matched_conditions += 1
+                end
+              when Array
+                if one_of_condition.all? { |k| value.key?(k) }
+                  matched_conditions += 1
+                  break
+                end
+              else
+                raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
               end
-            else
-              raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
             end
           end
 

data/lib/graphql/schema/validator.rb

@@ -48,16 +48,13 @@ module GraphQL
           EMPTY_ARRAY
         else
           validates_hash = validates_hash.dup
-          allow_null = validates_hash.delete(:allow_null)
-          allow_blank = validates_hash.delete(:allow_blank)
 
-          # This could be {...}.compact on Ruby 2.4+
           default_options = {}
-          if !allow_null.nil?
-            default_options[:allow_null] = allow_null
+          if validates_hash[:allow_null]
+            default_options[:allow_null] = validates_hash.delete(:allow_null)
           end
-          if !allow_blank.nil?
-            default_options[:allow_blank] = allow_blank
+          if validates_hash[:allow_blank]
+            default_options[:allow_blank] = validates_hash.delete(:allow_blank)
           end
 
           # allow_nil or allow_blank are the _only_ validations: