graphql 1.13.19 → 2.0.19

data/lib/graphql/analysis/query_depth.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    # A query reducer for measuring the depth of a given query.
-    #
-    # @example Logging the depth of a query
-    #   Schema.query_analyzers << GraphQL::Analysis::QueryDepth.new { |query, depth|  puts "GraphQL query depth: #{depth}" }
-    #   Schema.execute(query_str)
-    #   # GraphQL query depth: 8
-    #
-    class QueryDepth
-      def initialize(&block)
-        @depth_handler = block
-      end
-
-      def initial_value(query)
-        {
-          max_depth: 0,
-          current_depth: 0,
-          query: query,
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-          if visit_type == :enter
-            memo[:current_depth] += 1
-          else
-            if memo[:max_depth] < memo[:current_depth]
-              memo[:max_depth] = memo[:current_depth]
-            end
-            memo[:current_depth] -= 1
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        @depth_handler.call(memo[:query], memo[:max_depth])
-      end
-    end
-  end
-end

data/lib/graphql/analysis/reducer_state.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Analysis
-    class ReducerState
-      attr_reader :reducer
-      attr_accessor :memo, :errors
-
-      def initialize(reducer, query)
-        @reducer = reducer
-        @memo = initialize_reducer(reducer, query)
-        @errors = []
-      end
-
-      def call(visit_type, irep_node)
-        @memo = @reducer.call(@memo, visit_type, irep_node)
-      rescue AnalysisError => err
-        @errors << err
-      end
-
-      # Respond with any errors, if found. Otherwise, if the reducer accepts
-      # `final_value`, send it the last memo value.
-      # Otherwise, use the last value from the traversal.
-      # @return [Any] final memo value
-      def finalize_reducer
-        if @errors.any?
-          @errors
-        elsif reducer.respond_to?(:final_value)
-          reducer.final_value(@memo)
-        else
-          @memo
-        end
-      end
-
-      private
-
-      # If the reducer has an `initial_value` method, call it and store
-      # the result as `memo`. Otherwise, use `nil` as memo.
-      # @return [Any] initial memo value
-      def initialize_reducer(reducer, query)
-        if reducer.respond_to?(:initial_value)
-          reducer.initial_value(query)
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/graphql/argument.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class Argument
-    include GraphQL::Define::InstanceDefinable
-    deprecated_accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
-    attr_reader :default_value
-    attr_accessor :description, :name, :as, :deprecation_reason
-    attr_accessor :ast_node
-    attr_accessor :method_access
-    alias :graphql_name :name
-
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access, :deprecation_reason)
-
-    # @api private
-    module DefaultPrepare
-      def self.call(value, ctx); value; end
-    end
-
-    def initialize
-      @prepare_proc = DefaultPrepare
-    end
-
-    def initialize_copy(other)
-      @expose_as = nil
-    end
-
-    def default_value?
-      !!@has_default_value
-    end
-
-    def method_access?
-      # Treat unset as true -- only `false` should override
-      @method_access != false
-    end
-
-    def default_value=(new_default_value)
-      if new_default_value == NO_DEFAULT_VALUE
-        @has_default_value = false
-        @default_value = nil
-      else
-        @has_default_value = true
-        @default_value = GraphQL::Argument.deep_stringify(new_default_value)
-      end
-    end
-
-    # @!attribute name
-    #   @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
-
-    # @param new_input_type [GraphQL::BaseType, Proc] Assign a new input type for this argument (if it's a proc, it will be called after schema initialization)
-    def type=(new_input_type)
-      @clean_type = nil
-      @dirty_type = new_input_type
-    end
-
-    # @return [GraphQL::BaseType] the input type for this argument
-    def type
-      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
-    end
-
-    # @return [String] The name of this argument inside `resolve` functions
-    def expose_as
-      @expose_as ||= (@as || @name).to_s
-    end
-
-    # Backport this to support legacy-style directives
-    def keyword
-      @keyword ||= GraphQL::Schema::Member::BuildType.underscore(expose_as).to_sym
-    end
-
-    # @param value [Object] The incoming value from variables or query string literal
-    # @param ctx [GraphQL::Query::Context]
-    # @return [Object] The prepared `value` for this argument or `value` itself if no `prepare` function exists.
-    def prepare(value, ctx)
-      @prepare_proc.call(value, ctx)
-    end
-
-    # Assign a `prepare` function to prepare this argument's value before `resolve` functions are called.
-    # @param prepare_proc [#<call(value, ctx)>]
-    def prepare=(prepare_proc)
-      @prepare_proc = BackwardsCompatibility.wrap_arity(prepare_proc, from: 1, to: 2, name: "Argument#prepare(value, ctx)")
-    end
-
-    def type_class
-      metadata[:type_class]
-    end
-
-    NO_DEFAULT_VALUE = Object.new
-    # @api private
-    def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
-      name_s = name.to_s
-
-      # Move some positional args into keywords if they're present
-      description && kwargs[:description] ||= description
-      kwargs[:name] ||= name_s
-      kwargs[:default_value] ||= default_value
-      kwargs[:as] ||= as
-
-      unless prepare == DefaultPrepare
-        kwargs[:prepare] ||= prepare
-      end
-
-      if !type_or_argument.nil? && !type_or_argument.is_a?(GraphQL::Argument)
-        # Maybe a string, proc or BaseType
-        kwargs[:type] = type_or_argument
-      end
-
-      if type_or_argument.is_a?(GraphQL::Argument)
-        type_or_argument.redefine(**kwargs, &block)
-      else
-        GraphQL::Argument.define(**kwargs, &block)
-      end
-    end
-
-    # @api private
-    def self.deep_stringify(val)
-      case val
-      when Array
-        val.map { |v| deep_stringify(v) }
-      when Hash
-        new_val = {}
-        val.each do |k, v|
-          new_val[k.to_s] = deep_stringify(v)
-        end
-        new_val
-      else
-        val
-      end
-    end
-  end
-end

data/lib/graphql/authorization.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Authorization
-    class InaccessibleFieldsError < GraphQL::AnalysisError
-      # @return [Array<Schema::Field, GraphQL::Field>] Fields that failed `.accessible?` checks
-      attr_reader :fields
-
-      # @return [GraphQL::Query::Context] The current query's context
-      attr_reader :context
-
-      # @return [Array<GraphQL::InternalRepresentation::Node>] The visited nodes that failed `.accessible?` checks
-      # @see {#fields} for the Field definitions
-      attr_reader :irep_nodes
-
-      def initialize(fields:, irep_nodes:, context:)
-        @fields = fields
-        @irep_nodes = irep_nodes
-        @context = context
-        super("Some fields in this query are not accessible: #{fields.map(&:graphql_name).join(", ")}")
-      end
-    end
-
-    # @deprecated authorization at query runtime is generally a better idea.
-    module Analyzer
-      module_function
-      def initial_value(query)
-        {
-          schema: query.schema,
-          context: query.context,
-          inaccessible_nodes: [],
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          field = irep_node.definition
-          if field
-            schema = memo[:schema]
-            ctx = memo[:context]
-            next_field_accessible = schema.accessible?(field, ctx)
-            if !next_field_accessible
-              memo[:inaccessible_nodes] << irep_node
-            else
-              arg_accessible = true
-              irep_node.arguments.argument_values.each do |name, arg_value|
-                arg_accessible = schema.accessible?(arg_value.definition, ctx)
-                if !arg_accessible
-                  memo[:inaccessible_nodes] << irep_node
-                  break
-                end
-              end
-              if arg_accessible
-                return_type = field.type.unwrap
-                next_type_accessible = schema.accessible?(return_type, ctx)
-                if !next_type_accessible
-                  memo[:inaccessible_nodes] << irep_node
-                end
-              end
-            end
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        nodes = memo[:inaccessible_nodes]
-        if nodes.any?
-          fields = nodes.map do |node|
-            field_inst = node.definition
-            # Get the "source of truth" for this field
-            field_inst.metadata[:type_class] || field_inst
-          end
-          context = memo[:context]
-          err = InaccessibleFieldsError.new(fields: fields, irep_nodes: nodes, context: context)
-          context.schema.inaccessible_fields(err)
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/graphql/backtrace/legacy_tracer.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    module LegacyTracer
-      module_function
-
-      # Implement the {GraphQL::Tracing} API.
-      def trace(key, metadata)
-        case key
-        when "lex", "parse"
-          # No context here, don't have a query yet
-          nil
-        when "execute_multiplex", "analyze_multiplex"
-          # No query context yet
-          nil
-        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          query = metadata[:query] || metadata[:queries].first
-          push_data = query
-          multiplex = query.multiplex
-        when "execute_field", "execute_field_lazy"
-          # The interpreter passes `query:`, legacy passes `context:`
-          context = metadata[:context] || ((q = metadata[:query]) && q.context)
-          push_data = context
-          multiplex = context.query.multiplex
-        else
-          # Custom key, no backtrace data for this
-          nil
-        end
-
-        if push_data
-          multiplex.context[:last_graphql_backtrace_context] = push_data
-        end
-
-        if key == "execute_multiplex"
-          begin
-            yield
-          rescue StandardError => err
-            # This is an unhandled error from execution,
-            # Re-raise it with a GraphQL trace.
-            potential_context = metadata[:multiplex].context[:last_graphql_backtrace_context]
-
-            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
-              raise TracedError.new(err, potential_context)
-            else
-              raise
-            end
-          ensure
-            metadata[:multiplex].context.delete(:last_graphql_backtrace_context)
-          end
-        else
-          yield
-        end
-      end
-    end
-  end
-end

data/lib/graphql/backwards_compatibility.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # Helpers for migrating in a backwards-compatible way
-  # Remove this in GraphQL-Ruby 2.0, when all users of it will be gone.
-  # @api private
-  module BackwardsCompatibility
-    module_function
-    # Given a callable whose API used to take `from` arguments,
-    # check its arity, and if needed, apply a wrapper so that
-    # it can be called with `to` arguments.
-    # If a wrapper is applied, warn the application with `name`.
-    #
-    # If `last`, then use the last arguments to call the function.
-    def wrap_arity(callable, from:, to:, name:, last: false)
-      arity = get_arity(callable)
-      if arity == to || arity < 0
-        # It already matches, return it as is
-        callable
-      elsif arity == from
-        # It has the old arity, so wrap it with an arity converter
-        message ="#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments, see:"
-        backtrace = caller(0, 20)
-        # Find the first line in the trace that isn't library internals:
-        user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
-        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
-        wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
-        wrapper.new(callable, from)
-      else
-        raise "Can't wrap #{callable} (arity: #{arity}) to have arity #{to}"
-      end
-    end
-
-    def get_arity(callable)
-      case callable
-      when Method, Proc
-        callable.arity
-      else
-        callable.method(:call).arity
-      end
-    end
-
-    class FirstArgumentsWrapper
-      def initialize(callable, old_arity)
-        @callable = callable
-        @old_arity = old_arity
-      end
-
-      def call(*args)
-        backwards_compat_args = args.first(@old_arity)
-        @callable.call(*backwards_compat_args)
-      end
-    end
-
-    class LastArgumentsWrapper < FirstArgumentsWrapper
-      def call(*args)
-        backwards_compat_args = args.last(@old_arity)
-        @callable.call(*backwards_compat_args)
-      end
-    end
-  end
-end

data/lib/graphql/base_type.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-require "graphql/relay/type_extensions"
-
-module GraphQL
-  # The parent for all type classes.
-  class BaseType
-    include GraphQL::Define::NonNullWithBang
-    include GraphQL::Define::InstanceDefinable
-    include GraphQL::Relay::TypeExtensions
-
-    deprecated_accepts_definitions :name, :description,
-        :introspection,
-        :default_scalar,
-        :default_relay,
-        {
-          connection: GraphQL::Define::AssignConnection,
-          global_id_field: GraphQL::Define::AssignGlobalIdField,
-        }
-
-    ensure_defined(:graphql_name, :name, :description, :introspection?, :default_scalar?)
-
-    attr_accessor :ast_node
-
-    def initialize
-      @introspection = false
-      @default_scalar = false
-      @default_relay = false
-    end
-
-    def initialize_copy(other)
-      super
-      # Reset these derived defaults
-      @connection_type = nil
-      @edge_type = nil
-    end
-
-    # @return [String] the name of this type, must be unique within a Schema
-    attr_reader :name
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_name :name
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    def graphql_definition(silence_deprecation_warning: false)
-      itself
-    end
-
-    def type_class
-      metadata[:type_class]
-    end
-
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
-
-    # @return [String, nil] a description for this type
-    attr_accessor :description
-
-    # @return [Boolean] Is this type a predefined introspection type?
-    def introspection?
-      @introspection
-    end
-
-    # @return [Boolean] Is this type a built-in scalar type? (eg, `String`, `Int`)
-    def default_scalar?
-      @default_scalar
-    end
-
-    # @return [Boolean] Is this type a built-in Relay type? (`Node`, `PageInfo`)
-    def default_relay?
-      @default_relay
-    end
-
-    # @api private
-    attr_writer :introspection, :default_scalar, :default_relay
-
-    # @param other [GraphQL::BaseType] compare to this object
-    # @return [Boolean] are these types equivalent? (incl. non-null, list)
-    # @see {ModifiesAnotherType#==} for override on List & NonNull types
-    def ==(other)
-      other.is_a?(GraphQL::BaseType) && self.name == other.name
-    end
-
-    # If this type is modifying an underlying type,
-    # return the underlying type. (Otherwise, return `self`.)
-    def unwrap
-      self
-    end
-
-    # @return [GraphQL::NonNullType] a non-null version of this type
-    def to_non_null_type
-      GraphQL::NonNullType.new(of_type: self)
-    end
-
-    # @return [GraphQL::ListType] a list version of this type
-    def to_list_type
-      GraphQL::ListType.new(of_type: self)
-    end
-
-    module ModifiesAnotherType
-      def unwrap
-        self.of_type.unwrap
-      end
-
-      def ==(other)
-        other.is_a?(ModifiesAnotherType) && other.of_type == of_type
-      end
-    end
-
-    # Find out which possible type to use for `value`.
-    # Returns self if there are no possible types (ie, not Union or Interface)
-    def resolve_type(value, ctx)
-      self
-    end
-
-    # Print the human-readable name of this type using the query-string naming pattern
-    def to_s
-      name
-    end
-
-    alias :inspect :to_s
-    alias :to_type_signature :to_s
-
-    def valid_isolated_input?(value)
-      valid_input?(value, GraphQL::Query::NullContext)
-    end
-
-    def validate_isolated_input(value)
-      validate_input(value, GraphQL::Query::NullContext)
-    end
-
-    def coerce_isolated_input(value)
-      coerce_input(value, GraphQL::Query::NullContext)
-    end
-
-    def coerce_isolated_result(value)
-      coerce_result(value, GraphQL::Query::NullContext)
-    end
-
-    def valid_input?(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("valid_isolated_input?")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      validate_input(value, ctx).valid?
-    end
-
-    def validate_input(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("validate_isolated_input")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      if value.nil?
-        GraphQL::Query::InputValidationResult.new
-      else
-        validate_non_null_input(value, ctx)
-      end
-    end
-
-    def coerce_input(value, ctx = nil)
-      if value.nil?
-        nil
-      else
-        if ctx.nil?
-          warn_deprecated_coerce("coerce_isolated_input")
-          ctx = GraphQL::Query::NullContext
-        end
-        coerce_non_null_input(value, ctx)
-      end
-    end
-
-    def coerce_result(value, ctx)
-      raise GraphQL::RequiredImplementationMissingError
-    end
-
-    # Types with fields may override this
-    # @param name [String] field name to lookup for this type
-    # @return [GraphQL::Field, nil]
-    def get_field(name)
-      nil
-    end
-
-    # During schema definition, types can be defined inside procs or as strings.
-    # This function converts it to a type instance
-    # @return [GraphQL::BaseType]
-    def self.resolve_related_type(type_arg)
-      case type_arg
-      when Proc
-        # lazy-eval it, then try again
-        resolve_related_type(type_arg.call)
-      when String
-        # Get a constant by this name
-        resolve_related_type(Object.const_get(type_arg))
-      else
-        if type_arg.respond_to?(:graphql_definition)
-          type_arg.graphql_definition(silence_deprecation_warning: true)
-        else
-          type_arg
-        end
-      end
-    end
-
-    # Return a GraphQL string for the type definition
-    # @param schema [GraphQL::Schema]
-    # @param printer [GraphQL::Schema::Printer]
-    # @see {GraphQL::Schema::Printer#initialize for additional options}
-    # @return [String] type definition
-    def to_definition(schema, printer: nil, **args)
-      printer ||= GraphQL::Schema::Printer.new(schema, **args)
-      printer.print_type(self)
-    end
-
-    # Returns true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
-    def non_null?
-      false
-    end
-
-    # Returns true if this is a list type. A non-nullable list is considered a list.
-    def list?
-      false
-    end
-
-    private
-
-    def warn_deprecated_coerce(alt_method_name)
-      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
-    end
-  end
-end

data/lib/graphql/boolean_type.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::BOOLEAN_TYPE = GraphQL::Types::Boolean.graphql_definition(silence_deprecation_warning: true)