graphql 1.9.18 → 1.13.24

data/lib/graphql/query.rb

@@ -3,6 +3,7 @@ require "graphql/query/arguments"
 require "graphql/query/arguments_cache"
 require "graphql/query/context"
 require "graphql/query/executor"
+require "graphql/query/fingerprint"
 require "graphql/query/literal_input"
 require "graphql/query/null_context"
 require "graphql/query/result"
@@ -78,19 +79,25 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
+
+      # Use the `.graphql_definition` here which will return legacy types instead of classes
+      if schema.is_a?(Class) && !schema.interpreter?
+        schema = schema.graphql_definition
+      end
       @schema = schema
+      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
+      @warden = warden
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
       @operations = nil
       @validate = validate
-      # TODO: remove support for global tracers
-      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
         @tracers << GraphQL::Backtrace::Tracer
@@ -100,7 +107,7 @@ module GraphQL
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
       else
-        @provided_variables = variables
+        @provided_variables = variables || {}
       end
 
       @query_string = query_string || query
@@ -110,6 +117,10 @@ module GraphQL
         raise ArgumentError, "Query should only be provided a query string or a document, not both."
       end
 
+      if @query_string && !@query_string.is_a?(String)
+        raise ArgumentError, "Query string argument should be a String, got #{@query_string.class.name} instead."
+      end
+
       # A two-layer cache of type resolution:
       # { abstract_type => { value => resolved_type } }
       @resolved_types_cache = Hash.new do |h1, k1|
@@ -118,8 +129,6 @@ module GraphQL
         end
       end
 
-      @arguments_cache = ArgumentsCache.build(self)
-
       # Trying to execute a document
       # with no operations returns an empty hash
       @ast_variables = []
@@ -144,7 +153,11 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def_delegators :@schema, :interpreter?
+    def interpreter?
+      @interpreter
+    end
+
+    attr_accessor :multiplex
 
     def subscription_update?
       @subscription_topic && subscription?
@@ -156,7 +169,7 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.metadata[:type_class] || raise("Invariant: `lookahead` only works with class-based types")
+        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -186,9 +199,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
@@ -237,10 +248,60 @@ module GraphQL
     end
 
     # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @api private
-    # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
-    def arguments_for(irep_or_ast_node, definition)
-      @arguments_cache[irep_or_ast_node][definition]
+    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+    # @param definition [GraphQL::Schema::Field]
+    # @param parent_object [GraphQL::Schema::Object]
+    # @return Hash{Symbol => Object}
+    def arguments_for(ast_node, definition, parent_object: nil)
+      if interpreter?
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      else
+        arguments_cache[ast_node][definition]
+      end
+    end
+
+    def arguments_cache
+      if interpreter?
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      else
+        @arguments_cache ||= ArgumentsCache.build(self)
+      end
+    end
+
+    # A version of the given query string, with:
+    # - Variables inlined to the query
+    # - Strings replaced with `<REDACTED>`
+    # @return [String, nil] Returns nil if the query is invalid.
+    def sanitized_query_string(inline_variables: true)
+      with_prepared_ast {
+        schema.sanitized_printer.new(self, inline_variables: inline_variables).sanitized_query_string
+      }
+    end
+
+    # This contains a few components:
+    #
+    # - The selected operation name (or `anonymous`)
+    # - The fingerprint of the query string
+    # - The number of given variables (for readability)
+    # - The fingerprint of the given variables
+    #
+    # This fingerprint can be used to track runs of the same operation-variables combination over time.
+    #
+    # @see operation_fingerprint
+    # @see variables_fingerprint
+    # @return [String] An opaque hash identifying this operation-variables combination
+    def fingerprint
+      @fingerprint ||= "#{operation_fingerprint}/#{variables_fingerprint}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given query string and selected operation
+    def operation_fingerprint
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)
+    def variables_fingerprint
+      @variables_fingerprint ||= "#{provided_variables.size}/#{Fingerprint.generate(provided_variables.to_json)}"
     end
 
     def validation_pipeline
@@ -320,8 +381,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden = GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
-
+      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string
@@ -374,7 +434,6 @@ module GraphQL
 
       @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
         query: self,
-        validate: @validate,
         parse_error: parse_error,
         operation_name_error: operation_name_error,
         max_depth: @max_depth,

data/lib/graphql/railtie.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
-
 module GraphQL
   class Railtie < Rails::Railtie
+    config.before_configuration do
+      # Bootsnap compile cache has similar expiration properties,
+      # so we assume that if the user has bootsnap setup it's ok
+      # to piggy back on it.
+      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
+        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
+      end
+    end
+
     rake_tasks do
       # Defer this so that you only need the `parser` gem when you _run_ the upgrader
       def load_upgraders

data/lib/graphql/rake_task/validate.rb

@@ -7,6 +7,9 @@ module GraphQL
     desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
     task "graphql:pro:validate", [:gem_version] do |t, args|
       version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
       check = "\e[32m✓\e[0m"
       ex = "\e[31m✘\e[0m"
       puts "Validating graphql-pro v#{version}"

data/lib/graphql/rake_task.rb

@@ -76,15 +76,7 @@ module GraphQL
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
-      default_dependencies = if Rake::Task.task_defined?("environment")
-        [:environment]
-      else
-        []
-      end
-
-      all_options = DEFAULT_OPTIONS
-        .merge(dependencies: default_dependencies)
-        .merge(options)
+      all_options = DEFAULT_OPTIONS.merge(options)
       all_options.each do |k, v|
         self.public_send("#{k}=", v)
       end
@@ -106,6 +98,9 @@ module GraphQL
       result = schema.public_send(method_name, only: @only, except: @except, context: context)
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
       File.write(file, result)
     end
 
@@ -117,18 +112,26 @@ module GraphQL
       File.join(@directory, @json_outfile)
     end
 
+    def load_rails_environment_if_defined
+      if Rake::Task.task_defined?('environment')
+        Rake::Task['environment'].invoke
+      end
+    end
+
     # Use the Rake DSL to add tasks
     def define_task
       namespace(@namespace) do
         namespace("schema") do
           desc("Dump the schema to IDL in #{idl_path}")
           task :idl => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_definition, idl_path)
             puts "Schema IDL dumped into #{idl_path}"
           end
 
           desc("Dump the schema to JSON in #{json_path}")
           task :json => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_json, json_path)
             puts "Schema JSON dumped into #{json_path}"
           end

data/lib/graphql/relay/array_connection.rb

@@ -31,24 +31,22 @@ module GraphQL
         end
       end
 
-      private
-
       def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
+      private
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin

data/lib/graphql/relay/base_connection.rb

@@ -25,6 +25,10 @@ module GraphQL
         # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
+          # If it's a new-style connection object, it's already ready to go
+          if nodes.is_a?(GraphQL::Pagination::Connection)
+            return nodes
+          end
           # Check for class _names_ because classes can be redefined in Rails development
           nodes.class.ancestors.each do |ancestor|
             conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
@@ -55,6 +59,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
+        end
+
         @context = context
         @nodes = nodes
         @arguments = arguments
@@ -70,14 +81,18 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
-      rescue ArgumentError
-        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def first
-        @first ||= get_limited_arg(:first)
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       # The value passed as `after:`, if there was one
@@ -89,7 +104,7 @@ module GraphQL
       # The value passed as `last:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def last
-        @last ||= get_limited_arg(:last)
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       # The value passed as `before:`, if there was one
@@ -148,16 +163,18 @@ module GraphQL
 
       private
 
-      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
-      def get_limited_arg(arg_name)
-        arg_value = arguments[arg_name]
-        if arg_value.nil?
-          arg_value
-        elsif arg_value < 0
-          0
-        else
-          arg_value
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
         end
+        argument
       end
 
       def paged_nodes

data/lib/graphql/relay/connection_instrumentation.rb

@@ -10,10 +10,10 @@ module GraphQL
       def self.default_arguments
         @default_arguments ||= begin
           argument_definitions = [
-              ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-              ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
-              ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-              ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
             ]
 
           argument_definitions.reduce({}) do |memo, arg_defn|

data/lib/graphql/relay/connection_type.rb

@@ -1,25 +1,39 @@
 # frozen_string_literal: true
 module GraphQL
   module Relay
+    # @api deprecated
     module ConnectionType
       class << self
         # @return [Boolean] If true, connection types get a `nodes` shortcut field
-        attr_accessor :default_nodes_field
+        def default_nodes_field=(new_setting)
+          if new_setting
+            warn("GraphQL::Relay::ConnectionType will be removed in GraphQL 2.0.0; migrate to `GraphQL::Pagination::Connections` and remove this setting (`default_nodes_field = true`).")
+          end
+          @default_nodes_field = new_setting
+        end
+        attr_reader :default_nodes_field
+
         # @return [Boolean] If true, connections check for reverse-direction `has*Page` values
-        attr_accessor :bidirectional_pagination
+        def bidirectional_pagination=(new_setting)
+          if new_setting
+            warn("GraphQL::Relay::ConnectionType will be removed in GraphQL 2.0.0; migrate to `GraphQL::Pagination::Connections` and remove this setting (`bidirectional_pagination = true`).")
+          end
+          @bidirectional_pagination = new_setting
+        end
+        attr_reader :bidirectional_pagination
       end
 
       self.default_nodes_field = false
       self.bidirectional_pagination = false
 
-      # Create a connection which exposes edges of this type
+      # @api deprecated
       def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
         custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
-        ObjectType.define do
+        ObjectType.deprecated_define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
           edge_type ||= wrapped_type.edge_type
           name("#{type_name}Connection")

data/lib/graphql/relay/edge_type.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Relay
     module EdgeType
+      # @api deprecated
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name

data/lib/graphql/relay/edges_instrumentation.rb

@@ -16,7 +16,6 @@ module GraphQL
         end
       end
 
-
       class EdgesResolve
         def initialize(edge_class:, resolve:)
           @edge_class = edge_class
@@ -31,7 +30,7 @@ module GraphQL
           if ctx.schema.lazy?(nodes)
             nodes
           else
-            nodes.map { |item| @edge_class.new(item, parent) }
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
           end
         end
       end

data/lib/graphql/relay/global_id_resolve.rb

@@ -10,8 +10,7 @@ module GraphQL
         if obj.is_a?(GraphQL::Schema::Object)
           obj = obj.object
         end
-        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
-        ctx.query.schema.id_from_object(obj, type, ctx)
+        ctx.query.schema.id_from_object(obj, @type, ctx)
       end
     end
   end

data/lib/graphql/relay/mutation.rb

@@ -5,95 +5,10 @@ require "graphql/relay/mutation/result"
 
 module GraphQL
   module Relay
-    # Define a Relay mutation:
-    #   - give it a name (used for derived inputs & outputs)
-    #   - declare its inputs
-    #   - declare its outputs
-    #   - declare the mutation procedure
-    #
-    # `resolve` should return a hash with a key for each of the `return_field`s
-    #
-    # Inputs may also contain a `clientMutationId`
-    #
-    # @example Updating the name of an item
-    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
-    #     name "UpdateName"
-    #
-    #     input_field :name, !types.String
-    #     input_field :itemId, !types.ID
-    #
-    #     return_field :item, ItemType
-    #
-    #     resolve ->(inputs, ctx) {
-    #       item = Item.find_by_id(inputs[:id])
-    #       item.update(name: inputs[:name])
-    #       {item: item}
-    #     }
-    #   end
-    #
-    #   MutationType = GraphQL::ObjectType.define do
-    #     # The mutation object exposes a field:
-    #     field :updateName, field: UpdateNameMutation.field
-    #   end
-    #
-    #   # Then query it:
-    #   query_string = %|
-    #     mutation updateName {
-    #       updateName(input: {itemId: 1, name: "new name", clientMutationId: "1234"}) {
-    #         item { name }
-    #         clientMutationId
-    #     }|
-    #
-    #    GraphQL::Query.new(MySchema, query_string).result
-    #    # {"data" => {
-    #    #   "updateName" => {
-    #    #     "item" => { "name" => "new name"},
-    #    #     "clientMutationId" => "1234"
-    #    #   }
-    #    # }}
-    #
-    # @example Using a GraphQL::Function
-    #   class UpdateAttributes < GraphQL::Function
-    #     attr_reader :model, :return_as, :arguments
-    #
-    #     def initialize(model:, return_as:, attributes:)
-    #       @model = model
-    #       @arguments = {}
-    #       attributes.each do |name, type|
-    #         arg_name = name.to_s
-    #         @arguments[arg_name] = GraphQL::Argument.define(name: arg_name, type: type)
-    #       end
-    #       @arguments["id"] = GraphQL::Argument.define(name: "id", type: !GraphQL::ID_TYPE)
-    #       @return_as = return_as
-    #       @attributes = attributes
-    #     end
-    #
-    #     def type
-    #       fn = self
-    #       GraphQL::ObjectType.define do
-    #         name "Update#{fn.model.name}AttributesResponse"
-    #         field :clientMutationId, types.ID
-    #         field fn.return_as.keys[0], fn.return_as.values[0]
-    #       end
-    #     end
-    #
-    #     def call(obj, args, ctx)
-    #       record = @model.find(args[:inputs][:id])
-    #       new_values = {}
-    #       @attributes.each { |a| new_values[a] = args[a] }
-    #       record.update(new_values)
-    #       { @return_as => record }
-    #     end
-    #   end
-    #
-    #   UpdateNameMutation = GraphQL::Relay::Mutation.define do
-    #     name "UpdateName"
-    #     function UpdateAttributes.new(model: Item, return_as: { item: ItemType }, attributes: {name: !types.String})
-    #   end
-
+    # @api deprecated
     class Mutation
       include GraphQL::Define::InstanceDefinable
-      accepts_definitions(
+      deprecated_accepts_definitions(
         :name, :description, :resolve,
         :return_type,
         :return_interfaces,
@@ -115,6 +30,7 @@ module GraphQL
       alias :input_fields :arguments
 
       def initialize
+        GraphQL::Deprecation.warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
         @fields = {}
         @arguments = {}
         @has_generated_return_type = false

data/lib/graphql/relay/node.rb

@@ -5,6 +5,7 @@ module GraphQL
     module Node
       # @return [GraphQL::Field] a field for finding objects by their global ID.
       def self.field(**kwargs, &block)
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
@@ -18,6 +19,7 @@ module GraphQL
       end
 
       def self.plural_field(**kwargs, &block)
+        GraphQL::Deprecation.warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
@@ -29,6 +31,7 @@ module GraphQL
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
       def self.interface
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
         @interface ||= GraphQL::Types::Relay::Node.graphql_definition
       end
     end

data/lib/graphql/relay/page_info.rb

@@ -2,6 +2,6 @@
 module GraphQL
   module Relay
     # Wrap a Connection and expose its page info
-    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition
+    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition(silence_deprecation_warning: true)
   end
 end