graphql 1.13.10 → 2.0.2

data/lib/graphql/schema/interface.rb

@@ -4,8 +4,6 @@ module GraphQL
     module Interface
       include GraphQL::Schema::Member::GraphQLTypeNames
       module DefinitionMethods
-        include GraphQL::Schema::Member::CachedGraphQLDefinition
-        include GraphQL::Relay::TypeExtensions
         include GraphQL::Schema::Member::BaseDSLMethods
         # ConfigurationExtension's responsibilities are in `def included` below
         include GraphQL::Schema::Member::TypeSystemHelpers
@@ -100,34 +98,11 @@ module GraphQL
           end
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::InterfaceType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          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| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-            field_defn = field_inst.graphql_definition(silence_deprecation_warning: true)
-            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)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
       end
 
-      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
-      extend GraphQL::Schema::Member::AcceptsDefinition
-
       extend DefinitionMethods
 
       def unwrap

data/lib/graphql/schema/introspection_system.rb

@@ -89,9 +89,9 @@ module GraphQL
         case late_bound_type
         when GraphQL::Schema::LateBoundType
           @schema.get_type(late_bound_type.name)
-        when GraphQL::Schema::List, GraphQL::ListType
+        when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
-        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+        when GraphQL::Schema::NonNull
           resolve_late_binding(late_bound_type.of_type).to_non_null_type
         when Module
           # It's a normal type -- no change required
@@ -103,12 +103,7 @@ module GraphQL
 
       def load_constant(class_name)
         const = @custom_namespace.const_get(class_name)
-        if @class_based
-          dup_type_class(const)
-        else
-          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.deprecated_to_graphql
-        end
+        dup_type_class(const)
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
         dup_type_class(@built_in_namespace.const_get(class_name))

data/lib/graphql/schema/late_bound_type.rb

@@ -16,11 +16,11 @@ module GraphQL
       end
 
       def to_non_null_type
-        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
       end
 
       def to_list_type
-        @to_list_type ||= GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
       def inspect

data/lib/graphql/schema/list.rb

@@ -8,12 +8,6 @@ module GraphQL
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
-      end
-
       # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST
@@ -52,10 +46,11 @@ module GraphQL
       end
 
       def validate_non_null_input(value, ctx)
-        result = GraphQL::Query::InputValidationResult.new
+        result = nil
         ensure_array(value).each_with_index do |item, index|
           item_result = of_type.validate_input(item, ctx)
           if !item_result.valid?
+            result ||= GraphQL::Query::InputValidationResult.new
             result.merge_result!(index, item_result)
           end
         end

data/lib/graphql/schema/loader.rb

@@ -202,7 +202,6 @@ module GraphQL
               description: arg["description"],
               deprecation_reason: arg["deprecationReason"],
               required: false,
-              method_access: false,
               camelize: false,
             }
 

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

@@ -94,11 +94,6 @@ module GraphQL
           end
         end
 
-        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
-        def to_graphql
-          raise GraphQL::RequiredImplementationMissingError
-        end
-
         alias :unwrap :itself
 
         # Creates the default name for a schema member.

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

@@ -35,18 +35,16 @@ module GraphQL
             else
               maybe_type = constantize(type_expr)
               case maybe_type
-              when GraphQL::BaseType
-                maybe_type
               when Module
                 # This is a way to check that it's the right kind of module:
-                if maybe_type.respond_to?(:graphql_definition)
+                if maybe_type.respond_to?(:kind)
                   maybe_type
                 else
                   raise ArgumentError, "Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
                 end
               end
             end
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             type_expr
           when Array
             case type_expr.length
@@ -68,7 +66,7 @@ module GraphQL
             type_expr
           when Module
             # This is a way to check that it's the right kind of module:
-            if type_expr.respond_to?(:graphql_definition)
+            if type_expr.respond_to?(:kind)
               type_expr
             else
               # Eg `String` => GraphQL::Types::String
@@ -100,7 +98,7 @@ module GraphQL
 
         def to_type_name(something)
           case something
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             something.unwrap.name
           when Array
             to_type_name(something.first)

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

@@ -14,7 +14,7 @@ module GraphQL
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters
-        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
+        # @return [GraphQL::Schema::Argument] An instance of {argument_class}, created from `*args`
         def argument(*args, **kwargs, &block)
           kwargs[:owner] = self
           loads = kwargs[:loads]
@@ -78,23 +78,44 @@ module GraphQL
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
           @own_arguments ||= {}
-          prev_defn = own_arguments[arg_defn.name]
+          prev_defn = @own_arguments[arg_defn.name]
           case prev_defn
           when nil
-            own_arguments[arg_defn.name] = arg_defn
+            @own_arguments[arg_defn.name] = arg_defn
           when Array
             prev_defn << arg_defn
           when GraphQL::Schema::Argument
-            own_arguments[arg_defn.name] = [prev_defn, arg_defn]
+            @own_arguments[arg_defn.name] = [prev_defn, arg_defn]
           else
             raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
           end
           arg_defn
         end
 
+        def remove_argument(arg_defn)
+          prev_defn = @own_arguments[arg_defn.name]
+          case prev_defn
+          when nil
+            # done
+          when Array
+            prev_defn.delete(arg_defn)
+          when GraphQL::Schema::Argument
+            @own_arguments.delete(arg_defn.name)
+          else
+            raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
+          end
+          nil
+        end
+
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments(context = GraphQL::Query::NullContext)
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments(context) : nil)
+          inherited_arguments = if self.is_a?(Class) && superclass.respond_to?(:arguments)
+            superclass.arguments(context)
+          elsif defined?(@resolver_class) && @resolver_class
+            @resolver_class.field_arguments(context)
+          else
+            nil
+          end
           # Local definitions override inherited ones
           if own_arguments.any?
             own_arguments_that_apply = {}
@@ -125,6 +146,10 @@ module GraphQL
                 all_defns.merge!(ancestor.own_arguments)
               end
             end
+          elsif defined?(@resolver_class) && @resolver_class
+            all_defns = {}
+            all_defns.merge!(@resolver_class.own_field_arguments)
+            all_defns.merge!(own_arguments)
           else
             all_defns = own_arguments
           end
@@ -137,8 +162,13 @@ module GraphQL
         def get_argument(argument_name, context = GraphQL::Query::NullContext)
           warden = Warden.from_context(context)
           if !self.is_a?(Class)
-            a = own_arguments[argument_name]
-            a && Warden.visible_entry?(:visible_argument?, a, context, warden)
+            if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
+              visible_arg
+            elsif defined?(@resolver_class) && @resolver_class
+              @resolver_class.get_field_argument(argument_name, context)
+            else
+              nil
+            end
           else
             for ancestor in ancestors
               if ancestor.respond_to?(:own_arguments) &&
@@ -291,26 +321,22 @@ module GraphQL
                   # This object was loaded successfully
                   # and resolved to the right type,
                   # now apply the `.authorized?` class method if there is one
-                  if (class_based_type = application_object_type.type_class)
-                    context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
-                      if authed
-                        application_object
+                  context.schema.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                    if authed
+                      application_object
+                    else
+                      err = GraphQL::UnauthorizedError.new(
+                        object: application_object,
+                        type: application_object_type,
+                        context: context,
+                      )
+                      if self.respond_to?(:unauthorized_object)
+                        err.set_backtrace(caller)
+                        unauthorized_object(err)
                       else
-                        err = GraphQL::UnauthorizedError.new(
-                          object: application_object,
-                          type: class_based_type,
-                          context: context,
-                        )
-                        if self.respond_to?(:unauthorized_object)
-                          err.set_backtrace(caller)
-                          unauthorized_object(err)
-                        else
-                          raise err
-                        end
+                        raise err
                       end
                     end
-                  else
-                    application_object
                   end
                 end
               end

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

@@ -103,10 +103,10 @@ module GraphQL
         end
 
         def global_id_field(field_name, **kwargs)
-          id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
+          type = self
           field field_name, "ID", **kwargs, null: false
           define_method(field_name) do
-            id_resolver.call(object, {}, context)
+            context.schema.id_from_object(object, type, context)
           end
         end
 

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

@@ -23,8 +23,6 @@ module GraphQL
               int.interfaces.each do |next_interface|
                 implements(next_interface)
               end
-            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."
@@ -82,7 +80,7 @@ module GraphQL
             visible_interfaces.concat(superclass.interfaces(context))
           end
 
-          visible_interfaces
+          visible_interfaces.uniq
         end
       end
     end

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

@@ -10,9 +10,9 @@ module GraphQL
 
         def validate_input(val, ctx)
           if val.nil?
-            GraphQL::Query::InputValidationResult.new
+            Query::InputValidationResult::VALID
           else
-            validate_non_null_input(val, ctx)
+            validate_non_null_input(val, ctx) || Query::InputValidationResult::VALID
           end
         end
 

data/lib/graphql/schema/member.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
-require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
-require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_directives'
@@ -14,7 +12,6 @@ require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
 require 'graphql/schema/member/validates_input'
-require "graphql/relay/type_extensions"
 
 module GraphQL
   class Schema
@@ -24,8 +21,6 @@ module GraphQL
     # @api private
     class Member
       include GraphQLTypeNames
-      extend CachedGraphQLDefinition
-      extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
       extend BaseDSLMethods::ConfigurationExtension
       introspection(false)
@@ -41,5 +36,4 @@ end
 
 require 'graphql/schema/member/has_arguments'
 require 'graphql/schema/member/has_fields'
-require 'graphql/schema/member/instrumentation'
 require 'graphql/schema/member/build_type'

data/lib/graphql/schema/mutation.rb

@@ -63,15 +63,6 @@ module GraphQL
       extend GraphQL::Schema::Resolver::HasPayloadType
 
       class << self
-        # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, **kwargs, &block)
-          if args.empty?
-            raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
-          else
-            super
-          end
-        end
-
         def visible?(context)
           true
         end

data/lib/graphql/schema/non_null.rb

@@ -8,13 +8,7 @@ module GraphQL
     class NonNull < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_non_null_type
-      end
-
-       # @return [GraphQL::TypeKinds::NON_NULL]
+      # @return [GraphQL::TypeKinds::NON_NULL]
       def kind
         GraphQL::TypeKinds::NON_NULL
       end

data/lib/graphql/schema/object.rb

@@ -5,7 +5,6 @@ require "graphql/query/null_context"
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Member::HasInterfaces
 
@@ -99,48 +98,14 @@ module GraphQL
       class << self
         # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
         # It should help with debugging and bug tracker integrations.
-        def inherited(child_class)
-          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
-          super
-        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(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|
-            if int.is_a?(GraphQL::InterfaceType)
-              int_f = {}
-              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)
-            end
-          end
-          all_fields
-        end
-
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        # @return [GraphQL::ObjectType]
-        def to_graphql
-          obj_type = GraphQL::ObjectType.new
-          obj_type.name = graphql_name
-          obj_type.description = description
-          obj_type.structural_interface_type_memberships = interface_type_memberships
-          obj_type.introspection = introspection
-          obj_type.mutation = mutation
-          obj_type.ast_node = ast_node
-          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
+        def const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
           end
-
-          obj_type.metadata[:type_class] = self
-
-          obj_type
         end
 
         def kind

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -29,25 +29,19 @@ module GraphQL
       # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
       def resolve_with_support(**inputs)
-        # Without the interpreter, the inputs are unwrapped by an instrumenter.
-        # But when using the interpreter, no instrumenters are applied.
-        if context.interpreter?
-          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
+        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
-        else
-          input = inputs
         end
 
         if input
@@ -66,26 +60,42 @@ module GraphQL
           super()
         end
 
-        # Again, this is done by an instrumenter when using non-interpreter execution.
-        if context.interpreter?
-          context.schema.after_lazy(return_value) do |return_hash|
-            # It might be an error
-            if return_hash.is_a?(Hash)
-              return_hash[:client_mutation_id] = client_mutation_id
-            end
-            return_hash
+        context.schema.after_lazy(return_value) do |return_hash|
+          # It might be an error
+          if return_hash.is_a?(Hash)
+            return_hash[:client_mutation_id] = client_mutation_id
           end
-        else
-          return_value
+          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
 
         # Also apply this argument to the input type:
-        def argument(*args, **kwargs, &block)
+        def argument(*args, own_argument: false, **kwargs, &block)
           it = input_type # make sure any inherited arguments are already added to it
-          arg = super
+          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
@@ -125,15 +135,6 @@ module GraphQL
           @input_type ||= generate_input_type
         end
 
-        # Extend {Schema::Mutation.field_options} to add the `input` argument
-        def field_options
-          sig = super
-          # Arguments were added at the root, but they should be nested
-          sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
-          sig
-        end
-
         private
 
         # Generate the input type for the `input:` argument
@@ -141,11 +142,17 @@ module GraphQL
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
           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}")
+            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|

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

@@ -20,7 +20,17 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        alias :type :payload_type
+        def type(new_type = nil, null: nil)
+          if new_type
+            payload_type(new_type)
+            if !null.nil?
+              self.null(null)
+            end
+          else
+            super()
+          end
+        end
+
         alias :type_expr :payload_type
 
         def field_class(new_class = nil)