graphql 1.12.25 → 1.13.0

data/lib/graphql/schema/directive/flagged.rb

@@ -35,7 +35,7 @@ module GraphQL
           GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION,
         )
 
-        argument :by, [String], "Flags to check for this schema member", required: true
+        argument :by, [String], "Flags to check for this schema member"
 
         module VisibleByFlag
           def self.included(schema_class)
@@ -44,7 +44,7 @@ module GraphQL
 
           def visible?(context)
             if dir = self.directives.find { |d| d.is_a?(Flagged) }
-              relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f
+              relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f # rubocop:disable Development/ContextIsPassedCop -- definition-related
               relevant_flags && relevant_flags.any? && super
             else
               super

data/lib/graphql/schema/directive/include.rb

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Included when true."
 
         default_directive true

data/lib/graphql/schema/directive/skip.rb

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Skipped when true."
 
         default_directive true

data/lib/graphql/schema/directive/transform.rb

@@ -24,7 +24,7 @@ module GraphQL
           GraphQL::Schema::Directive::FIELD,
         )
 
-        argument :by, String, required: true,
+        argument :by, String,
           description: "The name of the transform to run if applicable"
 
         TRANSFORMS = [

data/lib/graphql/schema/directive.rb

@@ -61,9 +61,9 @@ module GraphQL
           defn.default_directive = self.default_directive
           defn.ast_node = ast_node
           defn.metadata[:type_class] = self
-          arguments.each do |name, arg_defn|
+          all_argument_definitions.each do |arg_defn|
             arg_graphql = arg_defn.to_graphql
-            defn.arguments[arg_graphql.name] = arg_graphql
+            defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class
           defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(defn)
@@ -116,10 +116,6 @@ module GraphQL
         @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
       end
 
-      def graphql_name
-        self.class.graphql_name
-      end
-
       LOCATIONS = [
         QUERY =                  :QUERY,
         MUTATION =               :MUTATION,

data/lib/graphql/schema/enum.rb

@@ -46,18 +46,66 @@ module GraphQL
         def value(*args, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
-          if own_values.key?(value.graphql_name)
-            raise ArgumentError, "#{value.graphql_name} is already defined for #{self.graphql_name}, please remove one of the definitions."
+          key = value.graphql_name
+          prev_value = own_values[key]
+          case prev_value
+          when nil
+            own_values[key] = value
+          when GraphQL::Schema::EnumValue
+            own_values[key] = [prev_value, value]
+          when Array
+            prev_value << value
+          else
+            raise "Invariant: Unexpected enum value for #{key.inspect}: #{prev_value.inspect}"
+          end
+          value
+        end
+
+        # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
+        def enum_values(context = GraphQL::Query::NullContext)
+          inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
+          visible_values = []
+          warden = Warden.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
+            end
+          end
+
+          if inherited_values
+            # Local values take precedence over inherited ones
+            inherited_values.each do |i_val|
+              if !visible_values.any? { |v| v.graphql_name == i_val.graphql_name }
+                visible_values << i_val
+              end
+            end
+          end
+
+          visible_values
+        end
+
+        # @return [Array<Schema::EnumValue>] An unfiltered list of all definitions
+        def all_enum_value_definitions
+          all_defns = if superclass.respond_to?(:all_enum_value_definitions)
+            superclass.all_enum_value_definitions
+          else
+            []
           end
-          own_values[value.graphql_name] = value
-          nil
+
+          @own_values && @own_values.each do |_key, value|
+            if value.is_a?(Array)
+              all_defns.concat(value)
+            else
+              all_defns << value
+            end
+          end
+
+          all_defns
         end
 
-        # @return [Hash<String => GraphQL::Schema::Enum::Value>] Possible values of this enum, keyed by name
-        def values
-          inherited_values = superclass <= GraphQL::Schema::Enum ? superclass.values : {}
-          # Local values take precedence over inherited ones
-          inherited_values.merge(own_values)
+        # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
+        def values(context = GraphQL::Query::NullContext)
+          enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
         # @return [GraphQL::EnumType]

data/lib/graphql/schema/enum_value.rb

@@ -55,7 +55,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_exec(self, &block)
+          instance_eval(&block)
         end
       end
 
@@ -85,6 +85,10 @@ module GraphQL
         enum_value
       end
 
+      def inspect
+        "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
       def visible?(_ctx); true; end
       def accessible?(_ctx); true; end
       def authorized?(_ctx); true; end

data/lib/graphql/schema/field/connection_extension.rb

@@ -42,7 +42,7 @@ module GraphQL
               value.after_value ||= original_arguments[:after]
               value.last_value ||= original_arguments[:last]
               value.before_value ||= original_arguments[:before]
-              value.arguments ||= original_arguments
+              value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
               value.field ||= field
               if field.has_max_page_size? && !value.has_max_page_size_override?
                 value.max_page_size = field.max_page_size

data/lib/graphql/schema/field.rb

@@ -5,10 +5,6 @@ require "graphql/schema/field/scope_extension"
 module GraphQL
   class Schema
     class Field
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
@@ -61,7 +57,7 @@ module GraphQL
       end
 
       def inspect
-        "#<#{self.class} #{path}#{arguments.any? ? "(...)" : ""}: #{type.to_type_signature}>"
+        "#<#{self.class} #{path}#{all_argument_definitions.any? ? "(...)" : ""}: #{type.to_type_signature}>"
       end
 
       alias :mutation :resolver
@@ -212,7 +208,7 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -220,9 +216,6 @@ module GraphQL
           if type.nil?
             raise ArgumentError, "missing second `type` argument or keyword `type:`"
           end
-          if null.nil?
-            raise ArgumentError, "missing keyword argument null:"
-          end
         end
         if (field || function || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
@@ -231,7 +224,6 @@ module GraphQL
         name_s = -name.to_s
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-        NameValidator.validate!(@name)
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
           raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
@@ -282,10 +274,15 @@ module GraphQL
         @legacy_edge_class = legacy_edge_class
 
         arguments.each do |name, arg|
-          if arg.is_a?(Hash)
+          case arg
+          when Hash
             argument(name: name, **arg)
-          else
+          when GraphQL::Schema::Argument
             add_argument(arg)
+          when Array
+            arg.each { |a| add_argument(a) }
+          else
+            raise ArgumentError, "Unexpected argument config (#{arg.class}): #{arg.inspect}"
           end
         end
 
@@ -412,6 +409,57 @@ module GraphQL
         end
       end
 
+      def calculate_complexity(query:, nodes:, child_complexity:)
+        if respond_to?(:complexity_for)
+          lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
+          complexity_for(child_complexity: child_complexity, query: query, lookahead: lookahead)
+        elsif connection?
+          arguments = query.arguments_for(nodes.first, self)
+          max_possible_page_size = nil
+          if arguments[:first]
+            max_possible_page_size = arguments[:first]
+          end
+          if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
+            max_possible_page_size = arguments[:last]
+          end
+
+          if max_possible_page_size.nil?
+            max_possible_page_size = max_page_size || query.schema.default_max_page_size
+          end
+
+          if max_possible_page_size.nil?
+            raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `max_page_size` or `default_max_page_size`"
+          else
+            metadata_complexity = 0
+            lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner)
+
+            if (page_info_lookahead = lookahead.selection(:page_info)).selected?
+              metadata_complexity += 1 # pageInfo
+              metadata_complexity += page_info_lookahead.selections.size # subfields
+            end
+
+            if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count)
+              metadata_complexity += 1
+            end
+            # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be?
+            items_complexity = child_complexity - metadata_complexity
+            # Add 1 for _this_ field
+            1 + (max_possible_page_size * items_complexity) + metadata_complexity
+          end
+        else
+          defined_complexity = complexity
+          case defined_complexity
+          when Proc
+            arguments = query.arguments_for(nodes.first, self)
+            defined_complexity.call(query.context, arguments.keyword_arguments, child_complexity)
+          when Numeric
+            defined_complexity + child_complexity
+          else
+            raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})")
+          end
+        end
+      end
+
       def complexity(new_complexity = nil)
         case new_complexity
         when Proc
@@ -494,9 +542,9 @@ module GraphQL
         field_defn.subscription_scope = @subscription_scope
         field_defn.ast_node = ast_node
 
-        arguments.each do |name, defn|
+        all_argument_definitions.each do |defn|
           arg_graphql = defn.to_graphql
-          field_defn.arguments[arg_graphql.name] = arg_graphql
+          field_defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
         end
 
         # Support a passed-in proc, one way or another
@@ -560,10 +608,36 @@ module GraphQL
           # The resolver will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
+          if (arg_values = context[:current_arguments])
+            # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
+            using_arg_values = true
+            arg_values = arg_values.argument_values
+          else
+            arg_values = args
+            using_arg_values = false
+          end
           # Faster than `.any?`
-          arguments.each_value do |arg|
-            if args.key?(arg.keyword) && !arg.authorized?(object, args[arg.keyword], context)
-              return false
+          arguments(context).each_value do |arg|
+            arg_key = arg.keyword
+            if arg_values.key?(arg_key)
+              arg_value = arg_values[arg_key]
+              if using_arg_values
+                if arg_value.default_used?
+                  # pass -- no auth required for default used
+                  next
+                else
+                  application_arg_value = arg_value.value
+                  if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
+                    application_arg_value.keyword_arguments
+                  end
+                end
+              else
+                application_arg_value = arg_value
+              end
+
+              if !arg.authorized?(object, application_arg_value, context)
+                return false
+              end
             end
           end
           true
@@ -660,7 +734,7 @@ module GraphQL
           ruby_kwargs = graphql_args.to_kwargs
           maybe_lazies = []
           # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
-          arguments.each do |name, arg_defn|
+          arguments(field_ctx).each do |name, arg_defn|
             ruby_kwargs_key = arg_defn.keyword
 
             if ruby_kwargs.key?(ruby_kwargs_key)

data/lib/graphql/schema/find_inherited_value.rb

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

data/lib/graphql/schema/finder.rb

@@ -38,7 +38,7 @@ module GraphQL
 
           find_in_directive(directive, path: path)
         else
-          type = schema.get_type(type_or_directive)
+          type = schema.get_type(type_or_directive) # rubocop:disable Development/ContextIsPassedCop -- build-time
 
           if type.nil?
             raise MemberNotFoundError, "Could not find type `#{type_or_directive}` in schema."
@@ -56,7 +56,7 @@ module GraphQL
 
       def find_in_directive(directive, path:)
         argument_name = path.shift
-        argument = directive.arguments[argument_name]
+        argument = directive.get_argument(argument_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
 
         if argument.nil?
           raise MemberNotFoundError, "Could not find argument `#{argument_name}` on directive #{directive}."
@@ -102,7 +102,7 @@ module GraphQL
 
       def find_in_field(field, path:)
         argument_name = path.shift
-        argument = field.arguments[argument_name]
+        argument = field.get_argument(argument_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
 
         if argument.nil?
           raise MemberNotFoundError, "Could not find argument `#{argument_name}` on field `#{field.name}`."
@@ -119,7 +119,7 @@ module GraphQL
 
       def find_in_input_object(input_object, path:)
         field_name = path.shift
-        input_field = input_object.arguments[field_name]
+        input_field = input_object.get_argument(field_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
 
         if input_field.nil?
           raise MemberNotFoundError, "Could not find input field `#{field_name}` on input object type `#{input_object.graphql_name}`."
@@ -136,7 +136,7 @@ module GraphQL
 
       def find_in_enum_type(enum_type, path:)
         value_name = path.shift
-        enum_value = enum_type.values[value_name]
+        enum_value = enum_type.enum_values.find { |v| v.graphql_name == value_name } # rubocop:disable Development/ContextIsPassedCop -- build-time, not runtime
 
         if enum_value.nil?
           raise MemberNotFoundError, "Could not find enum value `#{value_name}` on enum type `#{enum_type.graphql_name}`."

data/lib/graphql/schema/input_object.rb

@@ -31,7 +31,7 @@ module GraphQL
         end
         # Apply prepares, not great to have it duplicated here.
         maybe_lazies = []
-        self.class.arguments.each_value do |arg_defn|
+        self.class.arguments(context).each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
 
           if @ruby_style_hash.key?(ruby_kwargs_key)
@@ -123,7 +123,12 @@ module GraphQL
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
-          define_accessor_method(argument_defn.keyword)
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
           argument_defn
         end
 
@@ -134,8 +139,8 @@ module GraphQL
           type_defn.metadata[:type_class] = self
           type_defn.mutation = mutation
           type_defn.ast_node = ast_node
-          arguments.each do |name, arg|
-            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
+          all_argument_definitions.each do |arg|
+            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           # Make a reference to a classic-style Arguments class
           self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)
@@ -168,7 +173,7 @@ module GraphQL
           end
 
           # Inject missing required arguments
-          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
+          missing_required_inputs = self.arguments(ctx).reduce({}) do |m, (argument_name, argument)|
             if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
               m[argument_name] = nil
             end
@@ -219,7 +224,7 @@ module GraphQL
 
           result = {}
 
-          arguments.each do |input_key, input_field_defn|
+          arguments(ctx).each do |input_key, input_field_defn|
             input_value = value[input_key]
             if value.key?(input_key)
               result[input_key] = if input_value.nil?
@@ -232,13 +237,6 @@ module GraphQL
 
           result
         end
-
-        private
-
-        def define_accessor_method(method_name)
-          define_method(method_name) { self[method_name] }
-          alias_method(method_name, method_name)
-        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -16,6 +16,7 @@ module GraphQL
         include GraphQL::Schema::Member::HasAstNode
         include GraphQL::Schema::Member::HasUnresolvedTypeError
         include GraphQL::Schema::Member::HasDirectives
+        include GraphQL::Schema::Member::HasInterfaces
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -57,9 +58,10 @@ module GraphQL
             child_class.extend(Schema::Interface::DefinitionMethods)
 
             child_class.type_membership_class(self.type_membership_class)
-            child_class.own_interfaces << self
-            child_class.interfaces.reverse_each do |interface_defn|
-              child_class.extend(interface_defn::DefinitionMethods)
+            child_class.ancestors.reverse_each do |ancestor|
+              if ancestor.const_defined?(:DefinitionMethods)
+                child_class.extend(ancestor::DefinitionMethods)
+              end
             end
 
             # Use an instance variable to tell whether it's been included previously or not;
@@ -73,16 +75,13 @@ module GraphQL
             end
             child_class.introspection(introspection)
             child_class.description(description)
-            if overridden_graphql_name
-              child_class.graphql_name(overridden_graphql_name)
-            end
             # If interfaces are mixed into each other, only define this class once
             if !child_class.const_defined?(:UnresolvedTypeError, false)
               add_unresolved_type_error(child_class)
             end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end
@@ -108,9 +107,9 @@ module GraphQL
           type_defn.orphan_types = orphan_types
           type_defn.type_membership_class = self.type_membership_class
           type_defn.ast_node = ast_node
-          fields.each do |field_name, field_inst|
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
             field_defn = field_inst.graphql_definition
-            type_defn.fields[field_defn.name] = field_defn
+            type_defn.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
           type_defn.metadata[:type_class] = self
           if respond_to?(:resolve_type)
@@ -122,16 +121,6 @@ module GraphQL
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
-
-        protected
-
-        def own_interfaces
-          @own_interfaces ||= []
-        end
-
-        def interfaces
-          own_interfaces + (own_interfaces.map { |i| i.own_interfaces }).flatten
-        end
       end
 
       # Extend this _after_ `DefinitionMethods` is defined, so it will be used

data/lib/graphql/schema/member/accepts_definition.rb

@@ -85,8 +85,15 @@ module GraphQL
                 define_method(name) do |*args|
                   if args.any?
                     instance_variable_set(ivar_name, args)
+                  else
+                    if (v = instance_variable_get(ivar_name))
+                      v
+                    elsif (ancestor = ancestors.find { |i| i.respond_to?(name) && i != self })
+                      ancestor.public_send(name)
+                    else
+                      nil
+                    end
                   end
-                  instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
                 end
               end
             end

data/lib/graphql/schema/member/build_type.rb

@@ -4,10 +4,6 @@ module GraphQL
     class Member
       # @api private
       module BuildType
-        if !String.method_defined?(:match?)
-          using GraphQL::StringMatchBackport
-        end
-
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function