graphql 1.13.23 → 2.0.0

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]
@@ -167,7 +167,7 @@ module GraphQL
         # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
-          arg_defns = context.warden.arguments(self)
+          arg_defns = self.arguments(context)
           total_args_count = arg_defns.size
 
           finished_args = nil
@@ -181,7 +181,7 @@ module GraphQL
               argument_values = {}
               resolved_args_count = 0
               raised_error = false
-              arg_defns.each do |arg_defn|
+              arg_defns.each do |arg_name, arg_defn|
                 context.dataloader.append_job do
                   begin
                     arg_defn.coerce_into_values(parent_object, values, context, argument_values)
@@ -291,26 +291,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
 
@@ -134,7 +134,7 @@ module GraphQL
           if type.respond_to?(:kind) && type.kind.interface?
             implements_this_interface = false
             implementation_is_visible = false
-            warden.interface_type_memberships(self, context).each do |tm|
+            interface_type_memberships.each do |tm|
               if tm.abstract_type == type
                 implements_this_interface ||= true
                 if warden.visible_type_membership?(tm, context)

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."
@@ -57,17 +55,7 @@ module GraphQL
         end
 
         def interface_type_memberships
-          own_tms = own_interface_type_memberships
-          if (self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships))
-            inherited_tms = superclass.interface_type_memberships
-            if inherited_tms.size > 0
-              own_tms + inherited_tms
-            else
-              own_tms
-            end
-          else
-            own_tms
-          end
+          own_interface_type_memberships + ((self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships)) ? superclass.interface_type_memberships : [])
         end
 
         # param context [Query::Context] If omitted, skip filtering.

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

@@ -8,11 +8,11 @@ module GraphQL
           validate_input(val, ctx).valid?
         end
 
-        def validate_input(val, ctx, max_errors: nil)
+        def validate_input(val, ctx)
           if val.nil?
             GraphQL::Query::InputValidationResult.new
           else
-            validate_non_null_input(val, ctx, max_errors: max_errors) || Query::InputValidationResult::VALID
+            validate_non_null_input(val, ctx)
           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
@@ -37,13 +31,13 @@ module GraphQL
         "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
       end
 
-      def validate_input(value, ctx, max_errors: nil)
+      def validate_input(value, ctx)
         if value.nil?
           result = GraphQL::Query::InputValidationResult.new
           result.add_problem("Expected value to not be null")
           result
         else
-          of_type.validate_input(value, ctx, max_errors: max_errors)
+          of_type.validate_input(value, ctx)
         end
       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
 
@@ -104,45 +103,6 @@ module GraphQL
           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
-          end
-
-          obj_type.metadata[:type_class] = self
-
-          obj_type
-        end
-
         def kind
           GraphQL::TypeKinds::OBJECT
         end

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,17 +60,12 @@ 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
 

data/lib/graphql/schema/scalar.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
       class << self
@@ -14,20 +13,6 @@ module GraphQL
           val
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          type_defn = GraphQL::ScalarType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.coerce_result = method(:coerce_result)
-          type_defn.coerce_input = method(:coerce_input)
-          type_defn.metadata[:type_class] = self
-          type_defn.default_scalar = default_scalar
-          type_defn.ast_node = ast_node
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::SCALAR
         end
@@ -55,7 +40,7 @@ module GraphQL
           @default_scalar ||= false
         end
 
-        def validate_non_null_input(value, ctx, max_errors: nil)
+        def validate_non_null_input(value, ctx)
           result = Query::InputValidationResult.new
           coerced_result = begin
             ctx.query.with_error_handling do

data/lib/graphql/schema/union.rb

@@ -2,7 +2,6 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
@@ -33,21 +32,6 @@ module GraphQL
           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
-          type_defn.description = description
-          type_defn.ast_node = ast_node
-          type_defn.type_memberships = type_memberships
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn.metadata[:type_class] = self
-          type_defn
-        end
-
         def type_membership_class(membership_class = nil)
           if membership_class
             @type_membership_class = membership_class

data/lib/graphql/schema/warden.rb

@@ -78,8 +78,6 @@ module GraphQL
           def visible_type?(type, ctx); type.visible?(ctx); end
           def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
           def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
-          def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
-          def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
@@ -87,7 +85,7 @@ module GraphQL
       # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
       def initialize(filter, context:, schema:)
-        @schema = schema.interpreter? ? schema : schema.graphql_definition
+        @schema = schema
         # Cache these to avoid repeated hits to the inheritance chain when one isn't present
         @query = @schema.query
         @mutation = @schema.mutation
@@ -174,8 +172,8 @@ 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) } }
+      def arguments(argument_owner)
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
         @visible_arguments[argument_owner]
       end
 
@@ -233,13 +231,6 @@ module GraphQL
         visible?(type_membership)
       end
 
-      def interface_type_memberships(obj_type, _ctx = nil)
-        @type_memberships ||= read_through do |obj_t|
-          obj_t.interface_type_memberships
-        end
-        @type_memberships[obj_type]
-      end
-
       private
 
       def visible_and_reachable_type?(type_defn)

data/lib/graphql/schema/wrapper.rb

@@ -3,7 +3,6 @@
 module GraphQL
   class Schema
     class Wrapper
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::TypeSystemHelpers
 
       # @return [Class, Module] The inner type of this wrapping type, the type of which one or more objects may be present.
@@ -13,10 +12,6 @@ module GraphQL
         @of_type = of_type
       end
 
-      def to_graphql
-        raise GraphQL::RequiredImplementationMissingError
-      end
-
       def unwrap
         @of_type.unwrap
       end