graphql 2.1.0 → 2.1.1

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -21,6 +21,10 @@ module GraphQL
     # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
+      include GraphQL::Schema::HasSingleInputArgument
+
+      argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+
       # The payload should always include this field
       field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
@@ -31,34 +35,14 @@ module GraphQL
       def resolve_with_support(**inputs)
         input = inputs[:input].to_kwargs
 
-        new_extras = field ? field.extras : []
-        all_extras = self.class.extras + new_extras
-
-        # Transfer these from the top-level hash to the
-        # shortcutted `input:` object
-        all_extras.each do |ext|
-          # It's possible that the `extra` was not passed along by this point,
-          # don't re-add it if it wasn't given here.
-          if inputs.key?(ext)
-            input[ext] = inputs[ext]
-          end
-        end
-
         if input
           # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
           input_kwargs = input.to_h
           client_mutation_id = input_kwargs.delete(:client_mutation_id)
-        else
-          # Relay Classic Mutations with no `argument`s
-          # don't require `input:`
-          input_kwargs = {}
+          inputs[:input] = input_kwargs
         end
 
-        return_value = if input_kwargs.any?
-          super(**input_kwargs)
-        else
-          super()
-        end
+        return_value = super(**inputs)
 
         context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
@@ -68,112 +52,6 @@ module GraphQL
           return_hash
         end
       end
-
-      class << self
-        def dummy
-          @dummy ||= begin
-            d = Class.new(GraphQL::Schema::Resolver)
-            d.argument_class(self.argument_class)
-            # TODO make this lazier?
-            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
-            d
-          end
-        end
-
-        def field_arguments(context = GraphQL::Query::NullContext)
-          dummy.arguments(context)
-        end
-
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
-          dummy.get_argument(name, context)
-        end
-
-        def own_field_arguments
-          dummy.own_arguments
-        end
-
-        def all_field_argument_definitions
-          dummy.all_argument_definitions
-        end
-
-        # Also apply this argument to the input type:
-        def argument(*args, own_argument: false, **kwargs, &block)
-          it = input_type # make sure any inherited arguments are already added to it
-          arg = super(*args, **kwargs, &block)
-
-          # 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})
-        def input_object_class(new_class = nil)
-          if new_class
-            @input_object_class = new_class
-          end
-          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
-        end
-
-        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
-        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
-        def input_type(new_input_type = nil)
-          if new_input_type
-            @input_type = new_input_type
-          end
-          @input_type ||= generate_input_type
-        end
-
-        private
-
-        # Generate the input type for the `input:` argument
-        # To customize how input objects are generated, override this method
-        # @return [Class] a subclass of {.input_object_class}
-        def generate_input_type
-          mutation_args = all_argument_definitions
-          mutation_class = self
-          Class.new(input_object_class) do
-            class << self
-              def default_graphql_name
-                "#{self.mutation.graphql_name}Input"
-              end
-
-              def description(new_desc = nil)
-                super || "Autogenerated input type of #{self.mutation.graphql_name}"
-              end
-            end
-            mutation(mutation_class)
-            # 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.rb

@@ -214,6 +214,10 @@ module GraphQL
           arguments(context)
         end
 
+        def any_field_arguments?
+          any_arguments?
+        end
+
         def get_field_argument(name, context = GraphQL::Query::NullContext)
           get_argument(name, context)
         end

data/lib/graphql/schema/scalar.rb

@@ -19,9 +19,9 @@ module GraphQL
 
         def specified_by_url(new_url = nil)
           if new_url
-            @specified_by_url = new_url
-          elsif defined?(@specified_by_url)
-            @specified_by_url
+            directive(GraphQL::Schema::Directive::SpecifiedBy, url: new_url)
+          elsif (directive = directives.find { |dir| dir.graphql_name == "specifiedBy" })
+            directive.arguments[:url] # rubocop:disable Development/ContextIsPassedCop
           elsif superclass.respond_to?(:specified_by_url)
             superclass.specified_by_url
           else

data/lib/graphql/schema/warden.rb

@@ -188,7 +188,16 @@ module GraphQL
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner, ctx = nil)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
+        @visible_arguments ||= read_through { |o|
+          args = o.arguments(@context)
+          if args.any?
+            args = args.values
+            args.select! { |a| visible_argument?(a, @context) }
+            args
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
+        }
         @visible_arguments[argument_owner]
       end
 
@@ -211,7 +220,13 @@ module GraphQL
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible_type?(i) } }
+        @visible_interfaces ||= read_through { |t|
+          ints = t.interfaces(@context)
+          if ints.any?
+            ints.select! { |i| visible_type?(i) }
+          end
+          ints
+        }
         @visible_interfaces[obj_type]
       end
 
@@ -354,7 +369,9 @@ module GraphQL
       end
 
       def read_through
-        Hash.new { |h, k| h[k] = yield(k) }
+        h = Hash.new { |h, k| h[k] = yield(k) }
+        h.compare_by_identity
+        h
       end
 
       def reachable_type_set

data/lib/graphql/schema.rb

@@ -37,10 +37,12 @@ require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
+require "graphql/schema/directive/specified_by"
 require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
+require "graphql/schema/has_single_input_argument"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/subscription"
 
@@ -760,7 +762,16 @@ module GraphQL
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
-        find_inherited_value(:orphan_types, EMPTY_ARRAY) + own_orphan_types
+        inherited_ot = find_inherited_value(:orphan_types, nil)
+        if inherited_ot
+          if own_orphan_types.any?
+            inherited_ot + own_orphan_types
+          else
+            inherited_ot
+          end
+        else
+          own_orphan_types
+        end
       end
 
       def default_execution_strategy
@@ -962,7 +973,12 @@ module GraphQL
           new_directives.flatten.each { |d| directive(d) }
         end
 
-        find_inherited_value(:directives, default_directives).merge(own_directives)
+        inherited_dirs = find_inherited_value(:directives, default_directives)
+        if own_directives.any?
+          inherited_dirs.merge(own_directives)
+        else
+          inherited_dirs
+        end
       end
 
       # Attach a single directive to this schema
@@ -978,6 +994,7 @@ module GraphQL
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
           "oneOf" => GraphQL::Schema::Directive::OneOf,
+          "specifiedBy" => GraphQL::Schema::Directive::SpecifiedBy,
         }.freeze
       end
 

data/lib/graphql/static_validation/all_rules.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     # Default rules for {GraphQL::StaticValidation::Validator}
     #
-    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # Order is important here. Some validators skip later hooks.
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class BaseVisitor < GraphQL::Language::Visitor
+    class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
         @object_types = []

data/lib/graphql/static_validation/literal_validator.rb

@@ -111,7 +111,7 @@ module GraphQL
         # that required fields are missing
         required_field_names = @warden.arguments(type)
           .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
-          .map(&:name)
+          .map!(&:name)
 
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names

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

@@ -340,7 +340,7 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.query.get_field(owner_type, node.name)
+            definition = context.warden.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type

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

@@ -21,7 +21,7 @@ module GraphQL
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = context.warden.arguments(defn)
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
-          .map(&:name)
+          .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?

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

@@ -36,7 +36,7 @@ module GraphQL
 
         required_fields = context.warden.arguments(parent_type)
           .select{|arg| arg.type.kind.non_null?}
-          .map(&:graphql_name)
+          .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields

data/lib/graphql/static_validation/validation_context.rb

@@ -13,12 +13,15 @@ module GraphQL
 
       attr_reader :query, :errors, :visitor,
         :on_dependency_resolve_handlers,
-        :max_errors
+        :max_errors, :warden, :schema
 
-      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+
+      def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
+        @warden = query.warden
+        @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
         @max_errors = max_errors || Float::INFINITY

data/lib/graphql/tracing/appoptics_trace.rb

@@ -195,7 +195,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -226,7 +226,7 @@ module GraphQL
       end
 
       def graphql_multiplex(data)
-        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
         multiplex_transaction_name(names) if names.size > 1
 
         [:Operations, names.join(', ')]

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -117,7 +117,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -148,7 +148,7 @@ module GraphQL
       end
 
       def graphql_multiplex(data)
-        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
         multiplex_transaction_name(names) if names.size > 1
 
         [:Operations, names.join(', ')]

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -101,8 +101,8 @@ require "graphql/execution"
 require "graphql/pagination"
 require "graphql/schema"
 require "graphql/query"
-require "graphql/types"
 require "graphql/dataloader"
+require "graphql/types"
 require "graphql/static_validation"
 require "graphql/execution"
 require "graphql/schema/built_in_types"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -326,6 +326,7 @@ files:
 - lib/graphql/execution/interpreter/handles_raw_value.rb
 - lib/graphql/execution/interpreter/resolve.rb
 - lib/graphql/execution/interpreter/runtime.rb
+- lib/graphql/execution/interpreter/runtime/graphql_result.rb
 - lib/graphql/execution/lazy.rb
 - lib/graphql/execution/lazy/lazy_method_map.rb
 - lib/graphql/execution/lookahead.rb
@@ -360,6 +361,7 @@ files:
 - lib/graphql/language/parser.y
 - lib/graphql/language/printer.rb
 - lib/graphql/language/sanitized_printer.rb
+- lib/graphql/language/static_visitor.rb
 - lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/load_application_object_failed_error.rb
@@ -375,6 +377,7 @@ files:
 - lib/graphql/parse_error.rb
 - lib/graphql/query.rb
 - lib/graphql/query/context.rb
+- lib/graphql/query/context/scoped_context.rb
 - lib/graphql/query/fingerprint.rb
 - lib/graphql/query/input_validation_result.rb
 - lib/graphql/query/null_context.rb
@@ -409,6 +412,7 @@ files:
 - lib/graphql/schema/directive/include.rb
 - lib/graphql/schema/directive/one_of.rb
 - lib/graphql/schema/directive/skip.rb
+- lib/graphql/schema/directive/specified_by.rb
 - lib/graphql/schema/directive/transform.rb
 - lib/graphql/schema/enum.rb
 - lib/graphql/schema/enum_value.rb
@@ -418,6 +422,7 @@ files:
 - lib/graphql/schema/field_extension.rb
 - lib/graphql/schema/find_inherited_value.rb
 - lib/graphql/schema/finder.rb
+- lib/graphql/schema/has_single_input_argument.rb
 - lib/graphql/schema/input_object.rb
 - lib/graphql/schema/interface.rb
 - lib/graphql/schema/introspection_system.rb