graphql 1.9.0 → 2.1.1

data/lib/graphql/scalar_type.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # # GraphQL::ScalarType
-  #
-  # Scalars are plain values. They are leaf nodes in a GraphQL query tree.
-  #
-  # ## Built-in Scalars
-  #
-  # `GraphQL` comes with standard built-in scalars:
-  #
-  # |Constant | `.define` helper|
-  # |-------|--------|
-  # |`GraphQL::STRING_TYPE` | `types.String`|
-  # |`GraphQL::INT_TYPE` | `types.Int`|
-  # |`GraphQL::FLOAT_TYPE` | `types.Float`|
-  # |`GraphQL::ID_TYPE` | `types.ID`|
-  # |`GraphQL::BOOLEAN_TYPE` | `types.Boolean`|
-  #
-  # (`types` is an instance of `GraphQL::Definition::TypeDefiner`; `.String`, `.Float`, etc are methods which return built-in scalars.)
-  #
-  # ## Custom Scalars
-  #
-  # You can define custom scalars for your GraphQL server. It requires some special functions:
-  #
-  # - `coerce_input` is used to prepare incoming values for GraphQL execution. (Incoming values come from variables or literal values in the query string.)
-  # - `coerce_result` is used to turn Ruby values _back_ into serializable values for query responses.
-  #
-  # @example defining a type for Time
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) { Time.at(Float(value)) }
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  #
-  # You can customize the error message for invalid input values by raising a `GraphQL::CoercionError` within `coerce_input`:
-  #
-  # @example raising a custom error message
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value, ctx) do
-  #       begin
-  #         Time.at(Float(value))
-  #       rescue ArgumentError
-  #         raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to Float"
-  #       end
-  #     end
-  #
-  #     coerce_result ->(value, ctx) { value.to_f }
-  #   end
-  #
-  # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
-  #
-  # @example custom error response
-  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
-  #
-  class ScalarType < GraphQL::BaseType
-    accepts_definitions :coerce, :coerce_input, :coerce_result
-    ensure_defined :coerce_non_null_input, :coerce_result
-
-    module NoOpCoerce
-      def self.call(val, ctx)
-        val
-      end
-    end
-
-    def initialize
-      super
-      self.coerce = NoOpCoerce
-    end
-
-    def coerce=(proc)
-      self.coerce_input = proc
-      self.coerce_result = proc
-    end
-
-    def coerce_input=(coerce_input_fn)
-      if !coerce_input_fn.nil?
-        @coerce_input_proc = ensure_two_arg(coerce_input_fn, :coerce_input)
-      end
-    end
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-      @coerce_result_proc.call(value, ctx)
-    end
-
-    def coerce_result=(coerce_result_fn)
-      if !coerce_result_fn.nil?
-        @coerce_result_proc = ensure_two_arg(coerce_result_fn, :coerce_result)
-      end
-    end
-
-    def kind
-      GraphQL::TypeKinds::SCALAR
-    end
-
-    private
-
-    def ensure_two_arg(callable, method_name)
-      GraphQL::BackwardsCompatibility.wrap_arity(callable, from: 1, to: 2, name: "#{name}.#{method_name}(val, ctx)")
-    end
-
-    def coerce_non_null_input(value, ctx)
-      @coerce_input_proc.call(raw_coercion_input(value), ctx)
-    end
-
-    def raw_coercion_input(value)
-      if value.is_a?(GraphQL::Language::Nodes::InputObject)
-        value.to_h
-      elsif value.is_a?(Array)
-        value.map { |element| raw_coercion_input(element) }
-      elsif value.is_a?(GraphQL::Language::Nodes::Enum)
-        value.name
-      else
-        value
-      end
-    end
-
-    def validate_non_null_input(value, ctx)
-      result = Query::InputValidationResult.new
-      if coerce_non_null_input(value, ctx).nil?
-        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
-      end
-      result
-    end
-  end
-end

data/lib/graphql/schema/catchall_middleware.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # In early GraphQL versions, errors would be "automatically"
-    # rescued and replaced with `"Internal error"`. That behavior
-    # was undesirable but this middleware is offered for people who
-    # want to preserve it.
-    #
-    # It has a couple of differences from the previous behavior:
-    #
-    # - Other parts of the query _will_ be run (previously,
-    #   execution would stop when the error was raised and the result
-    #   would have no `"data"` key at all)
-    # - The entry in {Query::Context#errors} is a {GraphQL::ExecutionError}, _not_
-    #   the originally-raised error.
-    # - The entry in the `"errors"` key includes the location of the field
-    #   which raised the errors.
-    #
-    # @example Use CatchallMiddleware with your schema
-    #     # All errors will be suppressed and replaced with "Internal error" messages
-    #     MySchema.middleware << GraphQL::Schema::CatchallMiddleware
-    #
-    module CatchallMiddleware
-      MESSAGE = "Internal error"
-
-      # Rescue any error and replace it with a {GraphQL::ExecutionError}
-      # whose message is {MESSAGE}
-      def self.call(parent_type, parent_object, field_definition, field_args, query_context)
-        yield
-      rescue StandardError
-        GraphQL::ExecutionError.new(MESSAGE)
-      end
-    end
-  end
-end

data/lib/graphql/schema/default_parse_error.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    module DefaultParseError
-      def self.call(parse_error, ctx)
-        ctx.errors.push(parse_error)
-      end
-    end
-  end
-end

data/lib/graphql/schema/default_type_error.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    module DefaultTypeError
-      def self.call(type_error, ctx)
-        case type_error
-        when GraphQL::InvalidNullError
-          ctx.errors << type_error
-        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
-          raise type_error
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/member/accepts_definition.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  class Schema
-    class Member
-      # Support for legacy `accepts_definitions` functions.
-      #
-      # Keep the legacy handler hooked up. Class-based types and fields
-      # will call those legacy handlers during their `.to_graphql`
-      # methods.
-      #
-      # This can help out while transitioning from one to the other.
-      # Eventually, `GraphQL::{X}Type` objects will be removed entirely,
-      # But this can help during the transition.
-      #
-      # @example Applying a function to base object class
-      #   # Here's the legacy-style config, which we're calling back to:
-      #   GraphQL::ObjectType.accepts_definition({
-      #     permission_level: ->(defn, value) { defn.metadata[:permission_level] = value }
-      #   })
-      #
-      #   class BaseObject < GraphQL::Schema::Object
-      #     # Setup a named pass-through to the legacy config functions
-      #     accepts_definition :permission_level
-      #   end
-      #
-      #   class Account < BaseObject
-      #     # This value will be passed to the legacy handler:
-      #     permission_level 1
-      #   end
-      #
-      #   # The class gets a reader method which returns the args,
-      #   # only marginally useful.
-      #   Account.permission_level # => [1]
-      #
-      #   # The legacy handler is called, as before:
-      #   Account.graphql_definition.metadata[:permission_level] # => 1
-      module AcceptsDefinition
-        def self.included(child)
-          child.extend(AcceptsDefinitionDefinitionMethods)
-          child.prepend(ToGraphQLExtension)
-          child.prepend(InitializeExtension)
-        end
-
-        def self.extended(child)
-          if defined?(child::DefinitionMethods)
-            child::DefinitionMethods.include(AcceptsDefinitionDefinitionMethods)
-            child::DefinitionMethods.prepend(ToGraphQLExtension)
-          else
-            child.extend(AcceptsDefinitionDefinitionMethods)
-            # I tried to use `super`, but super isn't quite right
-            # since the method is defined in the same class itself,
-            # not the superclass
-            child.class_eval do
-              class << self
-                prepend(ToGraphQLExtension)
-              end
-            end
-          end
-        end
-
-        module AcceptsDefinitionDefinitionMethods
-          def accepts_definition(name)
-            own_accepts_definition_methods << name
-
-            ivar_name = "@#{name}_args"
-            if self.is_a?(Class)
-              define_singleton_method(name) do |*args|
-                if args.any?
-                  instance_variable_set(ivar_name, args)
-                end
-                instance_variable_get(ivar_name) || (superclass.respond_to?(name) ? superclass.public_send(name) : nil)
-              end
-
-              define_method(name) do |*args|
-                if args.any?
-                  instance_variable_set(ivar_name, args)
-                end
-                instance_variable_get(ivar_name)
-              end
-            else
-              # Special handling for interfaces, define it here
-              # so it's appropriately passed down
-              self::DefinitionMethods.module_eval do
-                define_method(name) do |*args|
-                  if args.any?
-                    instance_variable_set(ivar_name, args)
-                  end
-                  instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
-                end
-              end
-            end
-          end
-
-          def accepts_definition_methods
-            inherited_methods = if self.is_a?(Class)
-              superclass.respond_to?(:accepts_definition_methods) ? superclass.accepts_definition_methods : []
-            elsif self.is_a?(Module)
-              m = []
-              ancestors.each do |a|
-                if a.respond_to?(:own_accepts_definition_methods)
-                  m.concat(a.own_accepts_definition_methods)
-                end
-              end
-              m
-            else
-              self.class.accepts_definition_methods
-            end
-
-            own_accepts_definition_methods + inherited_methods
-          end
-
-          def own_accepts_definition_methods
-            @own_accepts_definition_methods ||= []
-          end
-        end
-
-        module ToGraphQLExtension
-          def to_graphql
-            defn = super
-            accepts_definition_methods.each do |method_name|
-              value = public_send(method_name)
-              if !value.nil?
-                defn = defn.redefine { public_send(method_name, *value) }
-              end
-            end
-            defn
-          end
-        end
-
-        module InitializeExtension
-          def initialize(*args, **kwargs, &block)
-            self.class.accepts_definition_methods.each do |method_name|
-              if kwargs.key?(method_name)
-                value = kwargs.delete(method_name)
-                if !value.is_a?(Array)
-                  value = [value]
-                end
-                instance_variable_set("@#{method_name}_args", value)
-              end
-            end
-            super(*args, **kwargs, &block)
-          end
-
-          def accepts_definition_methods
-            self.class.accepts_definition_methods
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/member/cached_graphql_definition.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  class Schema
-    class Member
-      # Adds a layer of caching over user-supplied `.to_graphql` methods.
-      # Users override `.to_graphql`, but all runtime code should use `.graphql_definition`.
-      # @api private
-      # @see concrete classes that extend this, eg {Schema::Object}
-      module CachedGraphQLDefinition
-        # A cached result of {.to_graphql}.
-        # It's cached here so that user-overridden {.to_graphql} implementations
-        # are also cached
-        def graphql_definition
-          @graphql_definition ||= to_graphql
-        end
-
-        # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
-        def initialize_copy(original)
-          super
-          @graphql_definition = nil
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/member/instrumentation.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-# test_via: ../object.rb
-
-module GraphQL
-  class Schema
-    class Member
-      module Instrumentation
-        module_function
-        def instrument(type, field)
-          return_type = field.type.unwrap
-          if (return_type.is_a?(GraphQL::ObjectType) && return_type.metadata[:type_class]) ||
-              return_type.is_a?(GraphQL::InterfaceType) ||
-              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:type_class] })
-            field = apply_proxy(field)
-          end
-
-          field
-        end
-
-        def before_query(query)
-          # Get the root type for this query
-          root_node = query.irep_selection
-          if root_node.nil?
-            # It's an invalid query, nothing to do here
-          else
-            root_type = query.irep_selection.return_type
-            # If it has a wrapper, apply it
-            wrapper_class = root_type.metadata[:type_class]
-            if wrapper_class
-              new_root_value = wrapper_class.authorized_new(query.root_value, query.context)
-              query.root_value = new_root_value
-            end
-          end
-        end
-
-        def after_query(_query)
-        end
-
-        private
-
-        module_function
-
-        def apply_proxy(field)
-          resolve_proc = field.resolve_proc
-          lazy_resolve_proc = field.lazy_resolve_proc
-          inner_return_type = field.type.unwrap
-          depth = list_depth(field.type)
-
-          field.redefine(
-            resolve: ProxiedResolve.new(inner_resolve: resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
-            lazy_resolve: ProxiedResolve.new(inner_resolve: lazy_resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
-          )
-        end
-
-        def list_depth(type, starting_at = 0)
-          case type
-          when GraphQL::ListType
-            list_depth(type.of_type, starting_at + 1)
-          when GraphQL::NonNullType
-            list_depth(type.of_type, starting_at)
-          else
-            starting_at
-          end
-        end
-
-        class ProxiedResolve
-          def initialize(inner_resolve:, list_depth:, inner_return_type:)
-            @inner_resolve = inner_resolve
-            @inner_return_type = inner_return_type
-            @list_depth = list_depth
-          end
-
-          def call(obj, args, ctx)
-            result = @inner_resolve.call(obj, args, ctx)
-            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || result.is_a?(GraphQL::ExecutionError) || ctx.wrapped_object
-              result
-            else
-              ctx.wrapped_object = true
-              proxy_to_depth(result, @list_depth, ctx)
-            end
-          end
-
-          private
-
-          def proxy_to_depth(inner_obj, depth, ctx)
-            if depth > 0
-              inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }
-            else
-              ctx.schema.after_lazy(inner_obj) do |inner_obj|
-                if inner_obj.nil?
-                  # For lists with nil, we need another nil check here
-                  nil
-                else
-                  concrete_type_or_lazy = case @inner_return_type
-                  when GraphQL::UnionType, GraphQL::InterfaceType
-                    ctx.query.resolve_type(@inner_return_type, inner_obj)
-                  when GraphQL::ObjectType
-                    @inner_return_type
-                  else
-                    raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
-                  end
-
-                  # .resolve_type may have returned a lazy
-                  ctx.schema.after_lazy(concrete_type_or_lazy) do |concrete_type|
-                    if concrete_type && (object_class = concrete_type.metadata[:type_class])
-                      # use the query-level context here, since it won't be field-specific anyways
-                      query_ctx = ctx.query.context
-                      object_class.authorized_new(inner_obj, query_ctx)
-                    else
-                      inner_obj
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/middleware_chain.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # Given {steps} and {arguments}, call steps in order, passing `(*arguments, next_step)`.
-    #
-    # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
-    class MiddlewareChain
-      extend Forwardable
-
-      # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
-      attr_reader :steps, :final_step
-
-      def initialize(steps: [], final_step: nil)
-        @steps = steps
-        @final_step = final_step
-      end
-
-      def initialize_copy(other)
-        super
-        @steps = other.steps.dup
-      end
-
-      def_delegators :@steps, :[], :first, :insert, :delete
-
-      def <<(callable)
-        add_middleware(callable)
-      end
-
-      def push(callable)
-        add_middleware(callable)
-      end
-
-      def ==(other)
-        steps == other.steps && final_step == other.final_step
-      end
-
-      def invoke(arguments)
-        invoke_core(0, arguments)
-      end
-
-      def concat(callables)
-        callables.each { |c| add_middleware(c) }
-      end
-
-      private
-
-      def invoke_core(index, arguments)
-        if index >= steps.length
-          final_step.call(*arguments)
-        else
-          steps[index].call(*arguments) { |next_args = arguments| invoke_core(index + 1, next_args) }
-        end
-      end
-
-      def add_middleware(callable)
-        # TODO: Stop wrapping callables once deprecated middleware becomes unsupported
-        steps << wrap(callable)
-      end
-
-      # TODO: Remove this code once deprecated middleware becomes unsupported
-      class MiddlewareWrapper
-        attr_reader :callable
-        def initialize(callable)
-          @callable = callable
-        end
-
-        def call(*args, &next_middleware)
-          callable.call(*args, next_middleware)
-        end
-      end
-
-      def wrap(callable)
-        if BackwardsCompatibility.get_arity(callable) == 6
-          warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
-          MiddlewareWrapper.new(callable)
-        else
-          callable
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/possible_types.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # Find the members of a union or interface within a given schema.
-    #
-    # (Although its members never change, unions are handled this way to simplify execution code.)
-    #
-    # Internally, the calculation is cached. It's assumed that schema members _don't_ change after creating the schema!
-    #
-    # @example Get an interface's possible types
-    #   possible_types = GraphQL::Schema::PossibleTypes(MySchema)
-    #   possible_types.possible_types(MyInterface)
-    #   # => [MyObjectType, MyOtherObjectType]
-    class PossibleTypes
-      def initialize(schema)
-        @object_types = schema.types.values.select { |type| type.kind.object? }
-
-        @interface_implementers = Hash.new do |hash, key|
-          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
-        end
-      end
-
-      def possible_types(type_defn)
-        case type_defn
-        when Module
-          possible_types(type_defn.graphql_definition)
-        when GraphQL::UnionType
-          type_defn.possible_types
-        when GraphQL::InterfaceType
-          @interface_implementers[type_defn]
-        when GraphQL::BaseType
-          [type_defn]
-        else
-          raise "Unexpected possible_types object: #{type_defn.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/rescue_middleware.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # - Store a table of errors & handlers
-    # - Rescue errors in a middleware chain, then check for a handler
-    # - If a handler is found, use it & return a {GraphQL::ExecutionError}
-    # - If no handler is found, re-raise the error
-    class RescueMiddleware
-      # @return [Hash] `{class => proc}` pairs for handling errors
-      attr_reader :rescue_table
-      def initialize
-        @rescue_table = {}
-      end
-
-      # @example Rescue from not-found by telling the user
-      #   MySchema.rescue_from(ActiveRecord::RecordNotFound) { "An item could not be found" }
-      #
-      # @param error_classes [Class] one or more classes of errors to rescue from
-      # @yield [err] A handler to return a message for these error instances
-      # @yieldparam [Exception] an error that was rescued
-      # @yieldreturn [String] message to put in GraphQL response
-      def rescue_from(*error_classes, &block)
-        error_classes.map{ |error_class| rescue_table[error_class] = block }
-      end
-
-      # Remove the handler for `error_classs`
-      # @param error_class [Class] the error class whose handler should be removed
-      def remove_handler(*error_classes)
-        error_classes.map{ |error_class| rescue_table.delete(error_class) }
-      end
-
-      # Implement the requirement for {GraphQL::Schema::MiddlewareChain}
-      def call(*args)
-        begin
-          yield
-        rescue StandardError => err
-          attempt_rescue(err)
-        end
-      end
-
-      private
-
-      def attempt_rescue(err)
-        rescue_table.each { |klass, handler|
-          if klass.is_a?(Class) && err.is_a?(klass) && handler
-            message = handler.call(err)
-            return GraphQL::ExecutionError.new(message)
-          end
-        }
-
-        raise(err)
-      end
-    end
-  end
-end