graphql 1.13.25 → 2.0.0

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)

data/lib/graphql/interface_type.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class InterfaceType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
-
-    attr_accessor :fields, :orphan_types, :resolve_type_proc
-    attr_writer :type_membership_class
-    ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
-
-    def initialize
-      super
-      @fields = {}
-      @orphan_types = []
-      @resolve_type_proc = nil
-    end
-
-    def initialize_copy(other)
-      super
-      @fields = other.fields.dup
-      @orphan_types = other.orphan_types.dup
-    end
-
-    def kind
-      GraphQL::TypeKinds::INTERFACE
-    end
-
-    def resolve_type(value, ctx)
-      ctx.query.resolve_type(self, value)
-    end
-
-    def resolve_type=(resolve_type_callable)
-      @resolve_type_proc = resolve_type_callable
-    end
-
-    # @return [GraphQL::Field] The defined field for `field_name`
-    def get_field(field_name)
-      fields[field_name]
-    end
-
-    # These fields don't have instrumenation applied
-    # @see [Schema#get_fields] Get fields with instrumentation
-    # @return [Array<GraphQL::Field>] All fields on this type
-    def all_fields
-      fields.values
-    end
-
-    # Get a possible type of this {InterfaceType} by type name
-    # @param type_name [String]
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and implements this {InterfaceType}, (else `nil`)
-    def get_possible_type(type_name, ctx)
-      type = ctx.query.get_type(type_name)
-      type if type && ctx.query.warden.possible_types(self).include?(type)
-    end
-
-    # Check if a type is a possible type of this {InterfaceType}
-    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [Boolean] True if the `type` exists and is a member of this {InterfaceType}, (else `nil`)
-    def possible_type?(type, ctx)
-      type_name = type.is_a?(String) ? type : type.graphql_name
-      !get_possible_type(type_name, ctx).nil?
-    end
-
-    def type_membership_class
-      @type_membership_class || GraphQL::Schema::TypeMembership
-    end
-  end
-end

data/lib/graphql/internal_representation/document.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    class Document
-      # @return [Hash<String, Node>] Operation Nodes of this query
-      attr_reader :operation_definitions
-
-      # @return [Hash<String, Node>] Fragment definition Nodes of this query
-      attr_reader :fragment_definitions
-
-      def initialize
-        @operation_definitions = {}
-        @fragment_definitions = {}
-      end
-
-      def [](key)
-        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
-        operation_definitions[key]
-      end
-
-      def each(&block)
-        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
-        operation_definitions.each(&block)
-      end
-    end
-  end
-end