graphql 1.13.16 → 2.0.0

data/lib/graphql/static_validation/base_visitor.rb

@@ -14,11 +14,6 @@ module GraphQL
         super(document)
       end
 
-      # This will be overwritten by {InternalRepresentation::Rewrite} if it's included
-      def rewrite_document
-        nil
-      end
-
       attr_reader :context
 
       # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
@@ -32,22 +27,13 @@ module GraphQL
       # Build a class to visit the AST and perform validation,
       # or use a pre-built class if rules is `ALL_RULES` or empty.
       # @param rules [Array<Module, Class>]
-      # @param rewrite [Boolean] if `false`, don't include rewrite
       # @return [Class] A class for validating `rules` during visitation
-      def self.including_rules(rules, rewrite: true)
+      def self.including_rules(rules)
         if rules.empty?
-          if rewrite
-            NoValidateVisitor
-          else
-            # It's not doing _anything?!?_
-            BaseVisitor
-          end
+          # It's not doing _anything?!?_
+          BaseVisitor
         elsif rules == ALL_RULES
-          if rewrite
-            DefaultVisitor
-          else
-            InterpreterVisitor
-          end
+          InterpreterVisitor
         else
           visitor_class = Class.new(self) do
             include(GraphQL::StaticValidation::DefinitionDependencies)
@@ -60,9 +46,6 @@ module GraphQL
             end
           end
 
-          if rewrite
-            visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
-          end
           visitor_class.include(ContextMethods)
           visitor_class
         end

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

@@ -12,20 +12,20 @@ module GraphQL
       private
 
       LOCATION_MESSAGE_NAMES = {
-        GraphQL::Directive::QUERY =>               "queries",
-        GraphQL::Directive::MUTATION =>            "mutations",
-        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
-        GraphQL::Directive::FIELD =>               "fields",
-        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
-        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
-        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::QUERY =>               "queries",
+        GraphQL::Schema::Directive::MUTATION =>            "mutations",
+        GraphQL::Schema::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Schema::Directive::FIELD =>               "fields",
+        GraphQL::Schema::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Schema::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Schema::Directive::INLINE_FRAGMENT =>     "inline fragments",
       }
 
       SIMPLE_LOCATIONS = {
-        Nodes::Field =>               GraphQL::Directive::FIELD,
-        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
-        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
-        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+        Nodes::Field =>               GraphQL::Schema::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Schema::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Schema::Directive::FRAGMENT_DEFINITION,
       }
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
@@ -34,7 +34,7 @@ module GraphQL
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
-          required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
+          required_location = GraphQL::Schema::Directive.const_get(ast_parent.operation_type.upcase)
           assert_includes_location(directive_defn, ast_directive, required_location)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]

data/lib/graphql/static_validation/validator.rb

@@ -28,12 +28,11 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.trace("validate", { validate: validate, query: query }) do
-          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
-          errors = if validate == false && can_skip_rewrite
+          errors = if validate == false
             []
           else
             rules_to_use = validate ? @rules : []
-            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
+            visitor_class = BaseVisitor.including_rules(rules_to_use)
 
             context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
@@ -42,18 +41,6 @@ module GraphQL
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
                 catch(:too_many_validation_errors) do
-                  # Attach legacy-style rules.
-                  # Only loop through rules if it has legacy-style rules
-                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                    legacy_rules.each do |rule_class_or_module|
-                      if rule_class_or_module.method_defined?(:validate)
-                        GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
-                        GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
-                        rule_class_or_module.new.validate(context)
-                      end
-                    end
-                  end
-
                   context.visitor.visit
                 end
               end
@@ -64,22 +51,13 @@ module GraphQL
             context.errors
           end
 
-          irep = if errors.empty? && context
-            # Only return this if there are no errors and validation was actually run
-            context.visitor.rewrite_document
-          else
-            nil
-          end
-
           {
             errors: errors,
-            irep: irep,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
           errors: [e],
-          irep: nil,
         }
       end
 

data/lib/graphql/static_validation.rb

@@ -7,7 +7,6 @@ require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"
 require "graphql/static_validation/literal_validator"
 require "graphql/static_validation/base_visitor"
-require "graphql/static_validation/no_validate_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
@@ -15,5 +14,4 @@ Dir.glob(rules_glob).each do |file|
 end
 
 require "graphql/static_validation/all_rules"
-require "graphql/static_validation/default_visitor"
 require "graphql/static_validation/interpreter_visitor"

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   class Subscriptions
-    class DefaultSubscriptionResolveExtension < GraphQL::Subscriptions::SubscriptionRoot::Extension
+    class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
       def resolve(context:, object:, arguments:)
         has_override_implementation = @field.resolver ||
           object.respond_to?(@field.resolver_method)
@@ -16,6 +16,43 @@ module GraphQL
           yield(object, arguments)
         end
       end
+
+      def after_resolve(value:, context:, object:, arguments:, **rest)
+        if value.is_a?(GraphQL::ExecutionError)
+          value
+        elsif (events = context.namespace(:subscriptions)[:events])
+          # This is the first execution, so gather an Event
+          # for the backend to register:
+          event = Subscriptions::Event.new(
+            name: field.name,
+            arguments: arguments_without_field_extras(arguments: arguments),
+            context: context,
+            field: field,
+          )
+          events << event
+          value
+        elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+            field.name,
+            arguments_without_field_extras(arguments: arguments),
+            field,
+            scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
+          )
+          # This is a subscription update. The resolver returned `skip` if it should be skipped,
+          # or else it returned an object to resolve the update.
+          value
+        else
+          # This is a subscription update, but this event wasn't triggered.
+          context.skip
+        end
+      end
+
+      private
+
+      def arguments_without_field_extras(arguments:)
+        arguments.dup.tap do |event_args|
+          field.extras.each { |k| event_args.delete(k) }
+        end
+      end
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -9,7 +9,7 @@ module GraphQL
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
 
-      # @return [GraphQL::Query::Arguments]
+      # @return [GraphQL::Execution::Interpreter::Arguments]
       attr_reader :arguments
 
       # @return [GraphQL::Query::Context]

data/lib/graphql/subscriptions/instrumentation.rb

@@ -9,16 +9,6 @@ module GraphQL
         @schema = schema
       end
 
-      def instrument(type, field)
-        if type == @schema.subscription.graphql_definition
-          # This is a root field of `subscription`
-          subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
-          field.redefine(resolve: subscribing_resolve_proc)
-        else
-          field
-        end
-      end
-
       # If needed, prepare to gather events which this query subscribes to
       def before_query(query)
         if query.subscription? && !query.subscription_update?
@@ -33,47 +23,6 @@ module GraphQL
           @schema.subscriptions.write_subscription(query, events)
         end
       end
-
-      private
-
-      class SubscriptionRegistrationResolve
-        def initialize(inner_proc)
-          @inner_proc = inner_proc
-        end
-
-        # Wrap the proc with subscription registration logic
-        def call(obj, args, ctx)
-          result = nil
-          if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
-            result = @inner_proc.call(obj, args, ctx)
-          end
-
-          events = ctx.namespace(:subscriptions)[:events]
-
-          if events
-            # This is the first execution, so gather an Event
-            # for the backend to register:
-            events << Subscriptions::Event.new(
-              name: ctx.field.name,
-              arguments: args,
-              context: ctx,
-            )
-            result
-          elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
-            if !result.nil?
-              result
-            elsif obj.is_a?(GraphQL::Schema::Object)
-              # The root object is _already_ the subscription update:
-              obj.object
-            else
-              obj
-            end
-          else
-            # This is a subscription update, but this event wasn't triggered.
-            ctx.skip
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/subscriptions.rb

@@ -5,7 +5,6 @@ require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
-require "graphql/subscriptions/subscription_root"
 require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
@@ -33,9 +32,6 @@ module GraphQL
 
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:query, instrumentation)
-      if !schema.is_a?(Class)
-        defn.instrument(:field, instrumentation)
-      end
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary
@@ -45,9 +41,6 @@ module GraphQL
     # @param schema [Class] the GraphQL schema this manager belongs to
     def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
-        if !schema.using_ast_analysis?
-          raise ArgumentError, "`broadcast: true` requires AST analysis, add `using GraphQL::Analysis::AST` to your schema or see https://graphql-ruby.org/queries/ast_analysis.html."
-        end
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
       end
       @default_broadcastable = default_broadcastable
@@ -233,7 +226,7 @@ module GraphQL
     # @return [Any] normalized arguments value
     def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
+      when GraphQL::Schema::Field, Class
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
           # it's a type, but not an input object
           return args
@@ -274,9 +267,7 @@ module GraphQL
         end
 
         if missing_arg_names.any?
-          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
-            "Subscription.#{arg_owner.name}"
-          elsif arg_owner.is_a?(GraphQL::Schema::Field)
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
           elsif arg_owner.is_a?(Class)
             arg_owner.graphql_name
@@ -287,9 +278,9 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType, GraphQL::Schema::List
+      when GraphQL::Schema::List
         args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
-      when GraphQL::NonNullType, GraphQL::Schema::NonNull
+      when GraphQL::Schema::NonNull
         normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,21 +17,15 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         tracer.trace(platform_key, service: service_name) do |span|
           span.span_type = 'custom'
-          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
-            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
-          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-
-            resource = if operations.empty?
+            span.resource = if operations.empty?
               first_query = data[:multiplex].queries.first
               fallback_transaction_name(first_query && first_query.context)
             else
               operations
             end
-            span.resource = resource if resource
 
             # For top span of query, set the analytics sample rate tag, if available.
             if analytics_enabled?
@@ -45,8 +39,6 @@ module GraphQL
             span.set_tag(:query_string, data[:query].query_string)
           end
 
-          prepare_span(key, data, span)
-
           yield
         end
       end
@@ -55,17 +47,8 @@ module GraphQL
         options.fetch(:service, 'ruby-graphql')
       end
 
-      # Implement this method in a subclass to apply custom tags to datadog spans
-      # @param key [String] The event being traced
-      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
-      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
-      def prepare_span(key, data, span)
-      end
-
       def tracer
-        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
-
-        options.fetch(:tracer, default_tracer)
+        options.fetch(:tracer, Datadog.tracer)
       end
 
       def analytics_available?

data/lib/graphql/tracing/platform_tracing.rb

@@ -10,10 +10,6 @@ module GraphQL
     class PlatformTracing
       class << self
         attr_accessor :platform_keys
-
-        def inherited(child_class)
-          child_class.platform_keys = self.platform_keys
-        end
       end
 
       def initialize(options = {})
@@ -45,7 +41,7 @@ module GraphQL
 
             platform_key = if trace_field
               context = data.fetch(:query).context
-              cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
+              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
             else
               nil
             end
@@ -61,14 +57,14 @@ module GraphQL
         when "authorized", "authorized_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type, :authorized) { platform_authorized_key(type) }
+          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type, :resolve_type) { platform_resolve_type_key(type) }
+          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -78,31 +74,8 @@ module GraphQL
         end
       end
 
-      def instrument(type, field)
-        return_type = field.type.unwrap
-        case return_type
-        when GraphQL::ScalarType, GraphQL::EnumType
-          if field.trace || (field.trace.nil? && @trace_scalars)
-            trace_field(type, field)
-          else
-            field
-          end
-        else
-          trace_field(type, field)
-        end
-      end
-
-      def trace_field(type, field)
-        new_f = field.redefine
-        new_f.metadata[:platform_key] = platform_field_key(type, field)
-        new_f
-      end
-
       def self.use(schema_defn, options = {})
         tracer = self.new(**options)
-        if !schema_defn.is_a?(Class)
-          schema_defn.instrument(:field, tracer)
-        end
         schema_defn.tracer(tracer)
       end
 
@@ -139,7 +112,7 @@ module GraphQL
       # If the key isn't present, the given block is called and the result is cached for `key`.
       #
       # @return [String]
-      def cached_platform_key(ctx, key, trace_phase)
+      def cached_platform_key(ctx, key)
         cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
         cache.fetch(key) { cache[key] = yield }
       end

data/lib/graphql/tracing.rb

@@ -6,7 +6,6 @@ require "graphql/tracing/appsignal_tracing"
 require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
-require "graphql/tracing/skylight_tracing"
 require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
 

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -36,7 +36,7 @@ module GraphQL
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
           # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
+          def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -49,7 +49,6 @@ module GraphQL
               type: [edge_type_class, null: edge_nullable],
               null: edges_nullable,
               description: "A list of edges.",
-              legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
               connection: false,
             }
 
@@ -159,13 +158,10 @@ module GraphQL
         def edges
           if @object.is_a?(GraphQL::Pagination::Connection)
             @object.edges
-          elsif context.interpreter?
+          else
             context.schema.after_lazy(object.edge_nodes) do |nodes|
               nodes.map { |n| self.class.edge_class.new(n, object) }
             end
-          else
-            # This is done by edges_instrumentation
-            @object.edge_nodes
           end
         end
       end

data/lib/graphql/types/relay/default_relay.rb

@@ -15,16 +15,6 @@ module GraphQL
         def default_relay?
           !!@default_relay
         end
-
-        def to_graphql
-          type_defn = if method(:to_graphql).super_method.arity
-            super(silence_deprecation_warning: true)
-          else
-            super
-          end
-          type_defn.default_relay = default_relay?
-          type_defn
-        end
       end
     end
   end

data/lib/graphql/types/relay/node_behaviors.rb

@@ -7,7 +7,11 @@ module GraphQL
         def self.included(child_module)
           child_module.extend(DefaultRelay)
           child_module.description("An object with an ID.")
-          child_module.field(:id, ID, null: false, description: "ID of the object.")
+          child_module.field(:id, ID, null: false, description: "ID of the object.", resolver_method: :default_global_id)
+        end
+
+        def default_global_id
+          context.schema.id_from_object(object, self, context)
         end
       end
     end

data/lib/graphql/types/relay.rb

@@ -14,8 +14,6 @@ require "graphql/types/relay/page_info"
 require "graphql/types/relay/base_connection"
 require "graphql/types/relay/base_edge"
 require "graphql/types/relay/node"
-require "graphql/types/relay/node_field"
-require "graphql/types/relay/nodes_field"
 
 module GraphQL
   module Types

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -81,27 +81,8 @@ require "graphql/integer_decoding_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/date_encoding_error"
-
-require "graphql/define"
-require "graphql/deprecation"
-require "graphql/base_type"
-require "graphql/object_type"
-require "graphql/enum_type"
-require "graphql/input_object_type"
-require "graphql/interface_type"
-require "graphql/list_type"
-require "graphql/non_null_type"
-require "graphql/union_type"
-
-require "graphql/argument"
-require "graphql/field"
 require "graphql/type_kinds"
-
-require "graphql/backwards_compatibility"
-require "graphql/scalar_type"
-
 require "graphql/name_validator"
-
 require "graphql/language"
 
 require_relative "./graphql/railtie" if defined? Rails::Railtie
@@ -116,15 +97,8 @@ require "graphql/query"
 require "graphql/types"
 require "graphql/dataloader"
 require "graphql/filter"
-require "graphql/internal_representation"
-require "graphql/directive"
 require "graphql/static_validation"
 require "graphql/execution"
-require "graphql/boolean_type"
-require "graphql/float_type"
-require "graphql/id_type"
-require "graphql/int_type"
-require "graphql/string_type"
 require "graphql/schema/built_in_types"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
@@ -132,49 +106,11 @@ require "graphql/introspection"
 require "graphql/relay"
 
 require "graphql/version"
-require "graphql/compatibility"
-require "graphql/function"
 require "graphql/subscriptions"
 require "graphql/parse_error"
 require "graphql/backtrace"
 
-require "graphql/deprecated_dsl"
-require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"
-
-module GraphQL
-  # Ruby has `deprecate_constant`,
-  # but I don't see a way to give a nice error message in that case,
-  # so I'm doing this instead.
-  DEPRECATED_INT_TYPE = INT_TYPE
-  DEPRECATED_FLOAT_TYPE = FLOAT_TYPE
-  DEPRECATED_STRING_TYPE = STRING_TYPE
-  DEPRECATED_BOOLEAN_TYPE = BOOLEAN_TYPE
-  DEPRECATED_ID_TYPE = ID_TYPE
-
-  remove_const :INT_TYPE
-  remove_const :FLOAT_TYPE
-  remove_const :STRING_TYPE
-  remove_const :BOOLEAN_TYPE
-  remove_const :ID_TYPE
-
-  def self.const_missing(const_name)
-    deprecated_const_name = :"DEPRECATED_#{const_name}"
-    if const_defined?(deprecated_const_name)
-      deprecated_type = const_get(deprecated_const_name)
-      deprecated_caller = caller(1, 1).first
-      # Don't warn about internal uses, like `types.Int`
-      if !deprecated_caller.include?("lib/graphql")
-        warn "GraphQL::#{const_name} is deprecated and will be removed in GraphQL-Ruby 2.0, use GraphQL::Types::#{deprecated_type.graphql_name} instead. (from #{deprecated_caller})"
-      end
-      deprecated_type
-    else
-      super
-    end
-  end
-end
+require "graphql/deprecation"