graphql 1.13.16 → 2.0.0

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
@@ -51,24 +45,15 @@ module GraphQL
         end
       end
 
-      def validate_non_null_input(value, ctx, max_errors: nil)
+      def validate_non_null_input(value, ctx)
         result = GraphQL::Query::InputValidationResult.new
         ensure_array(value).each_with_index do |item, index|
           item_result = of_type.validate_input(item, ctx)
-          unless item_result.valid?
-            if max_errors
-              if max_errors == 0
-                add_max_errros_reached_message(result)
-                break
-              end
-
-              max_errors -= 1
-            end
-
+          if !item_result.valid?
             result.merge_result!(index, item_result)
           end
         end
-        result.valid? ? nil : result
+        result
       end
 
       private
@@ -81,12 +66,6 @@ module GraphQL
           [value]
         end
       end
-
-      def add_max_errros_reached_message(result)
-        message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
-        item_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        result.merge_result!(nil, item_result)
-      end
     end
   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]
@@ -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
 

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."

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

@@ -85,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

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