graphql 1.13.12 → 2.0.21

data/lib/graphql/execution/lazy/resolve.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    class Lazy
-      # Helpers for dealing with data structures containing {Lazy} instances
-      # @api private
-      module Resolve
-        # Mutate `value`, replacing {Lazy} instances in place with their resolved values
-        # @return [void]
-
-        # This object can be passed like an array, but it doesn't allocate an
-        # array until it's used.
-        #
-        # There's one crucial difference: you have to _capture_ the result
-        # of `#<<`. (This _works_ with arrays but isn't required, since it has a side-effect.)
-        # @api private
-        module NullAccumulator
-          def self.<<(item)
-            [item]
-          end
-
-          def self.empty?
-            true
-          end
-        end
-
-        def self.resolve(value)
-          lazies = resolve_in_place(value)
-          deep_sync(lazies)
-        end
-
-        def self.resolve_in_place(value)
-          acc = each_lazy(NullAccumulator, value)
-
-          if acc.empty?
-            Lazy::NullResult
-          else
-            Lazy.new {
-              acc.each_with_index { |ctx, idx|
-                acc[idx] = ctx.value.value
-              }
-              resolve_in_place(acc)
-            }
-          end
-        end
-
-        # If `value` is a collection,
-        # add any {Lazy} instances in the collection
-        # to `acc`
-        # @return [void]
-        def self.each_lazy(acc, value)
-          case value
-          when Hash
-            value.each do |key, field_result|
-              acc = each_lazy(acc, field_result)
-            end
-          when Array
-            value.each do |field_result|
-              acc = each_lazy(acc, field_result)
-            end
-          when Query::Context::SharedMethods
-            field_value = value.value
-            case field_value
-            when Lazy
-              acc = acc << value
-            when Enumerable # shortcut for Hash & Array
-              acc = each_lazy(acc, field_value)
-            end
-          end
-
-          acc
-        end
-
-        # Traverse `val`, triggering resolution for each {Lazy}.
-        # These {Lazy}s are expected to mutate their owner data structures
-        # during resolution! (They're created with the `.then` calls in `resolve_in_place`).
-        # @return [void]
-        def self.deep_sync(val)
-          case val
-          when Lazy
-            deep_sync(val.value)
-          when Array
-            val.each { |v| deep_sync(v.value) }
-          when Hash
-            val.each { |k, v| deep_sync(v.value) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/execution/typecast.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    # @api private
-    module Typecast
-      # @return [Boolean]
-      def self.subtype?(parent_type, child_type)
-        if parent_type == child_type
-          # Equivalent types are subtypes
-          true
-        elsif child_type.is_a?(GraphQL::NonNullType)
-          # A non-null type is a subtype of a nullable type
-          # if its inner type is a subtype of that type
-          if parent_type.is_a?(GraphQL::NonNullType)
-            subtype?(parent_type.of_type, child_type.of_type)
-          else
-            subtype?(parent_type, child_type.of_type)
-          end
-        else
-          case parent_type
-          when GraphQL::InterfaceType
-            # A type is a subtype of an interface
-            # if it implements that interface
-            case child_type
-            when GraphQL::ObjectType
-              child_type.interfaces.include?(parent_type)
-            else
-              false
-            end
-          when GraphQL::UnionType
-            # A type is a subtype of that union
-            # if the union includes that type
-            parent_type.possible_types.include?(child_type)
-          when GraphQL::ListType
-            # A list type is a subtype of another list type
-            # if its inner type is a subtype of the other inner type
-            case child_type
-            when GraphQL::ListType
-              subtype?(parent_type.of_type, child_type.of_type)
-            else
-              false
-            end
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/field/resolve.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Field
-    # Create resolve procs ahead of time based on a {GraphQL::Field}'s `name`, `property`, and `hash_key` configuration.
-    module Resolve
-      module_function
-
-      # @param field [GraphQL::Field] A field that needs a resolve proc
-      # @return [Proc] A resolver for this field, based on its config
-      def create_proc(field)
-        if field.property
-          MethodResolve.new(field)
-        elsif !field.hash_key.nil?
-          HashKeyResolve.new(field.hash_key)
-        else
-          NameResolve.new(field)
-        end
-      end
-
-      # These only require `obj` as input
-      class BuiltInResolve
-      end
-
-      # Resolve the field by `public_send`ing `@method_name`
-      class MethodResolve < BuiltInResolve
-        def initialize(field)
-          @method_name = field.property.to_sym
-        end
-
-        def call(obj, args, ctx)
-          obj.public_send(@method_name)
-        end
-      end
-
-      # Resolve the field by looking up `@hash_key` with `#[]`
-      class HashKeyResolve < BuiltInResolve
-        def initialize(hash_key)
-          @hash_key = hash_key
-        end
-
-        def call(obj, args, ctx)
-          obj[@hash_key]
-        end
-      end
-
-      # Call the field's name at query-time since
-      # it might have changed
-      class NameResolve < BuiltInResolve
-        def initialize(field)
-          @field = field
-        end
-
-        def call(obj, args, ctx)
-          obj.public_send(@field.name)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/field.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-require "graphql/field/resolve"
-
-module GraphQL
-  # @api deprecated
-  class Field
-    include GraphQL::Define::InstanceDefinable
-    deprecated_accepts_definitions :name, :description, :deprecation_reason,
-      :resolve, :lazy_resolve,
-      :type, :arguments,
-      :property, :hash_key, :complexity,
-      :mutation, :function,
-      :edge_class,
-      :relay_node_field,
-      :relay_nodes_field,
-      :subscription_scope,
-      :trace,
-      :introspection,
-      argument: GraphQL::Define::AssignArgument
-
-    ensure_defined(
-      :name, :deprecation_reason, :description, :description=, :property, :hash_key,
-      :mutation, :arguments, :complexity, :function,
-      :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
-      :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope,
-      :introspection?
-    )
-
-    # @return [Boolean] True if this is the Relay find-by-id field
-    attr_accessor :relay_node_field
-
-    # @return [Boolean] True if this is the Relay find-by-ids field
-    attr_accessor :relay_nodes_field
-
-    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called to return the field's value
-    attr_reader :resolve_proc
-
-    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called trigger a lazy resolution
-    attr_reader :lazy_resolve_proc
-
-    # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
-    attr_reader :name
-    alias :graphql_name :name
-
-    # @return [String, nil] The client-facing description of this field
-    attr_accessor :description
-
-    # @return [String, nil] The client-facing reason why this field is deprecated (if present, the field is deprecated)
-    attr_accessor :deprecation_reason
-
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    attr_accessor :arguments
-
-    # @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
-    attr_accessor :mutation
-
-    # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `->(query_ctx, args, child_complexity) { } # Numeric`
-    attr_accessor :complexity
-
-    # @return [Symbol, nil] The method to call on `obj` to return this field (overrides {#name} if present)
-    attr_reader :property
-
-    # @return [Object, nil] The key to access with `obj.[]` to resolve this field (overrides {#name} if present)
-    attr_reader :hash_key
-
-    # @return [Object, GraphQL::Function] The function used to derive this field
-    attr_accessor :function
-
-    attr_accessor :arguments_class
-
-    attr_writer :connection
-    attr_writer :introspection
-
-    # @return [nil, String] Prefix for subscription names from this field
-    attr_accessor :subscription_scope
-
-    # @return [Boolean] True if this field should be traced. By default, fields are only traced if they are not a ScalarType or EnumType.
-    attr_accessor :trace
-
-    attr_accessor :ast_node
-
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
-
-    # @return [Boolean]
-    def connection?
-      @connection
-    end
-
-    # @return [nil, Class]
-    # @api private
-    attr_accessor :edge_class
-
-    # @return [Boolean]
-    def edges?
-      !!@edge_class
-    end
-
-    # @return [nil, Integer]
-    attr_accessor :connection_max_page_size
-
-    def initialize
-      @complexity = 1
-      @arguments = {}
-      @resolve_proc = build_default_resolver
-      @lazy_resolve_proc = DefaultLazyResolve
-      @relay_node_field = false
-      @connection = false
-      @connection_max_page_size = nil
-      @edge_class = nil
-      @trace = nil
-      @introspection = false
-    end
-
-    def initialize_copy(other)
-      ensure_defined
-      super
-      @arguments = other.arguments.dup
-    end
-
-    # @return [Boolean] Is this field a predefined introspection field?
-    def introspection?
-      @introspection
-    end
-
-    # Get a value for this field
-    # @example resolving a field value
-    #   field.resolve(obj, args, ctx)
-    #
-    # @param object [Object] The object this field belongs to
-    # @param arguments [Hash] Arguments declared in the query
-    # @param context [GraphQL::Query::Context]
-    def resolve(object, arguments, context)
-      resolve_proc.call(object, arguments, context)
-    end
-
-    # Provide a new callable for this field's resolve function. If `nil`,
-    # a new resolve proc will be build based on its {#name}, {#property} or {#hash_key}.
-    # @param new_resolve_proc [<#call(obj, args, ctx)>, nil]
-    def resolve=(new_resolve_proc)
-      @resolve_proc = new_resolve_proc || build_default_resolver
-    end
-
-    def type=(new_return_type)
-      @clean_type = nil
-      @dirty_type = new_return_type
-    end
-
-    # Get the return type for this field.
-    def type
-      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
-    end
-
-    def name=(new_name)
-      old_name = defined?(@name) ? @name : nil
-      @name = new_name
-
-      if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
-        # Since the NameResolve would use the old field name,
-        # reset resolve proc when the name has changed
-        self.resolve = nil
-      end
-    end
-
-    # @param new_property [Symbol] A method to call to resolve this field. Overrides the existing resolve proc.
-    def property=(new_property)
-      @property = new_property
-      self.resolve = nil # reset resolve proc
-    end
-
-    # @param new_hash_key [Symbol] A key to access with `#[key]` to resolve this field. Overrides the existing resolve proc.
-    def hash_key=(new_hash_key)
-      @hash_key = new_hash_key
-      self.resolve = nil # reset resolve proc
-    end
-
-    def to_s
-      "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
-    end
-
-    # If {#resolve} returned an object which should be handled lazily,
-    # this method will be called later to force the object to return its value.
-    # @param obj [Object] The {#resolve}-provided object, registered with {Schema#lazy_resolve}
-    # @param args [GraphQL::Query::Arguments] Arguments to this field
-    # @param ctx [GraphQL::Query::Context] Context for this field
-    # @return [Object] The result of calling the registered method on `obj`
-    def lazy_resolve(obj, args, ctx)
-      @lazy_resolve_proc.call(obj, args, ctx)
-    end
-
-    # Assign a new resolve proc to this field. Used for {#lazy_resolve}
-    def lazy_resolve=(new_lazy_resolve_proc)
-      @lazy_resolve_proc = new_lazy_resolve_proc
-    end
-
-    # Prepare a lazy value for this field. It may be `then`-ed and resolved later.
-    # @return [GraphQL::Execution::Lazy] A lazy wrapper around `obj` and its registered method name
-    def prepare_lazy(obj, args, ctx)
-      GraphQL::Execution::Lazy.new {
-        lazy_resolve(obj, args, ctx)
-      }
-    end
-
-    def type_class
-      metadata[:type_class]
-    end
-
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
-
-    private
-
-    def build_default_resolver
-      GraphQL::Field::Resolve.create_proc(self)
-    end
-
-    module DefaultLazyResolve
-      def self.call(obj, args, ctx)
-        ctx.schema.sync_lazy(obj)
-      end
-    end
-  end
-end

data/lib/graphql/float_type.rb

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

data/lib/graphql/function.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class Function
-    def self.inherited(subclass)
-      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
-    end
-
-    # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
-    def arguments
-      self.class.arguments
-    end
-
-    # @return [GraphQL::BaseType] Return type
-    def type
-      self.class.type
-    end
-
-    # @return [Object] This function's resolver
-    def call(obj, args, ctx)
-      raise GraphQL::RequiredImplementationMissingError
-    end
-
-    # @return [String, nil]
-    def description
-      self.class.description
-    end
-
-    # @return [String, nil]
-    def deprecation_reason
-      self.class.deprecation_reason
-    end
-
-    # @return [Integer, Proc]
-    def complexity
-      self.class.complexity || 1
-    end
-
-    class << self
-      # Define an argument for this function & its subclasses
-      # @see {GraphQL::Field} same arguments as the `argument` definition helper
-      # @return [void]
-      def argument(*args, **kwargs, &block)
-        argument = GraphQL::Argument.from_dsl(*args, **kwargs, &block)
-        own_arguments[argument.name] = argument
-        nil
-      end
-
-      # @return [Hash<String => GraphQL::Argument>] Arguments for this function class, including inherited arguments
-      def arguments
-        if parent_function?
-          own_arguments.merge(superclass.arguments)
-        else
-          own_arguments.dup
-        end
-      end
-
-      # Provides shorthand access to GraphQL's built-in types
-      def types
-        GraphQL::Define::TypeDefiner.instance
-      end
-
-      # Get or set the return type for this function class & descendants
-      # @return [GraphQL::BaseType]
-      def type(premade_type = nil, &block)
-        if block_given?
-          @type = GraphQL::ObjectType.define(&block)
-        elsif premade_type
-          @type = premade_type
-        elsif parent_function?
-          @type || superclass.type
-        else
-          @type
-        end
-      end
-
-      def build_field(function)
-        GraphQL::Field.define(
-          arguments: function.arguments,
-          complexity: function.complexity,
-          type: function.type,
-          resolve: function,
-          description: function.description,
-          function: function,
-          deprecation_reason: function.deprecation_reason,
-        )
-      end
-
-      # Class-level reader/writer which is inherited
-      # @api private
-      def self.inherited_value(name)
-        self.class_eval <<-RUBY
-          def #{name}(new_value = nil)
-            if new_value
-              @#{name} = new_value
-            elsif parent_function?
-              @#{name} || superclass.#{name}
-            else
-              @#{name}
-            end
-          end
-        RUBY
-      end
-
-      # @!method description(new_value = nil)
-      #   Get or set this class's description
-      inherited_value(:description)
-      # @!method deprecation_reason(new_value = nil)
-      #   Get or set this class's deprecation_reason
-      inherited_value(:deprecation_reason)
-      # @!method complexity(new_value = nil)
-      #   Get or set this class's complexity
-      inherited_value(:complexity)
-
-      private
-
-      # Does this function inherit from another function?
-      def parent_function?
-        superclass <= GraphQL::Function
-      end
-
-      # Arguments defined on this class (not superclasses)
-      def own_arguments
-        @own_arguments ||= {}
-      end
-    end
-  end
-end

data/lib/graphql/id_type.rb

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

data/lib/graphql/input_object_type.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class InputObjectType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_accepts_definitions(
-      :arguments, :mutation,
-      input_field: GraphQL::Define::AssignArgument,
-      argument: GraphQL::Define::AssignArgument
-    )
-
-    attr_accessor :mutation, :arguments, :arguments_class
-    ensure_defined(:mutation, :arguments, :input_fields)
-    alias :input_fields :arguments
-
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
-
-    # @!attribute arguments
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-
-
-    def initialize
-      super
-      @arguments = {}
-    end
-
-    def initialize_copy(other)
-      super
-      @arguments = other.arguments.dup
-    end
-
-    def kind
-      GraphQL::TypeKinds::INPUT_OBJECT
-    end
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      # Allow the application to provide values as :symbols, and convert them to the strings
-      value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
-
-      result = {}
-
-      arguments.each do |input_key, input_field_defn|
-        input_value = value[input_key]
-        if value.key?(input_key)
-          result[input_key] = if input_value.nil?
-            nil
-          else
-            input_field_defn.type.coerce_result(input_value, ctx)
-          end
-        end
-      end
-
-      result
-    end
-
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
-
-    private
-
-    def coerce_non_null_input(value, ctx)
-      input_values = {}
-      defaults_used = Set.new
-
-      arguments.each do |input_key, input_field_defn|
-        field_value = value[input_key]
-
-        if value.key?(input_key)
-          coerced_value = input_field_defn.type.coerce_input(field_value, ctx)
-          input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
-        elsif input_field_defn.default_value?
-          coerced_value = input_field_defn.type.coerce_input(input_field_defn.default_value, ctx)
-          input_values[input_key] = coerced_value
-          defaults_used << input_key
-        end
-      end
-
-      result = arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
-      result.prepare
-    end
-
-    # @api private
-    INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key, value object responding to `to_h` or `to_unsafe_h`."
-
-    def validate_non_null_input(input, ctx)
-      warden = ctx.warden
-      result = GraphQL::Query::InputValidationResult.new
-
-      if input.is_a?(Array)
-        result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-        return result
-      end
-
-      # We're not actually _using_ the coerced result, we're just
-      # using these methods to make sure that the object will
-      # behave like a hash below, when we call `each` on it.
-      begin
-        input.to_h
-      rescue
-        begin
-          # Handle ActionController::Parameters:
-          input.to_unsafe_h
-        rescue
-          # We're not sure it'll act like a hash, so reject it:
-          result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-          return result
-        end
-      end
-
-      visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
-
-      # Items in the input that are unexpected
-      input.each do |name, value|
-        if visible_arguments_map[name].nil?
-          result.add_problem("Field is not defined on #{self.graphql_name}", [name])
-        end
-      end
-
-      # Items in the input that are expected, but have invalid values
-      visible_arguments_map.map do |name, field|
-        field_result = field.type.validate_input(input[name], ctx)
-        if !field_result.valid?
-          result.merge_result!(name, field_result)
-        end
-      end
-
-      result
-    end
-  end
-end

data/lib/graphql/int_type.rb

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