graphql 1.13.23 → 2.0.0

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

@@ -1,164 +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)
-                  else
-                    if (v = instance_variable_get(ivar_name))
-                      v
-                    elsif (ancestor = ancestors.find { |i| i.respond_to?(name) && i != self })
-                      ancestor.public_send(name)
-                    else
-                      nil
-                    end
-                  end
-                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(*args, **kwargs)
-
-            defn = if args.empty? && kwargs.empty?
-              super()
-            else
-              super
-            end
-            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,58 +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(silence_deprecation_warning: false)
-          @graphql_definition ||= begin
-            unless silence_deprecation_warning
-              message = "Legacy `.graphql_definition` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.graphql_definition` to use a class-based definition instead."
-              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
-              GraphQL::Deprecation.warn(message + caller_message)
-            end
-            deprecated_to_graphql
-          end
-        end
-
-        def deprecated_to_graphql
-          case method(:to_graphql).arity
-          when 0
-            to_graphql
-          else
-            to_graphql(silence_deprecation_warning: true)
-          end
-        end
-
-        # This is for a common interface with .define-based types
-        def type_class
-          self
-        end
-
-        # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
-        def initialize_copy(original)
-          super
-          @graphql_definition = nil
-        end
-
-        module DeprecatedToGraphQL
-          def to_graphql(silence_deprecation_warning: false)
-            unless silence_deprecation_warning
-              message = "Legacy `.to_graphql` objects are deprecated and will be removed in GraphQL-Ruby 2.0. Remove `.to_graphql` to use a class-based definition instead."
-              caller_message = "\n\nCalled on #{self.inspect} from:\n #{caller(1, 25).map { |l| "  #{l}" }.join("\n")}"
-              GraphQL::Deprecation.warn(message + caller_message)
-            end
-            super()
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-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)
-              new_root_value = query.schema.sync_lazy(new_root_value)
-              if new_root_value.nil?
-                # This is definitely a hack,
-                # but we need some way to tell execute.rb not to run.
-                query.context[:__root_unauthorized] = true
-              end
-              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? || execution_errors?(result) || ctx.wrapped_object
-              result
-            else
-              ctx.wrapped_object = true
-              proxy_to_depth(result, @list_depth, ctx)
-            end
-          end
-
-          private
-
-          def execution_errors?(result)
-            result.is_a?(GraphQL::ExecutionError) ||
-              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
-          end
-
-          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
-          GraphQL::Deprecation.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,44 +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 |h1, ctx|
-          h1[ctx] = Hash.new do |h2, int_type|
-            h2[int_type] = @object_types.select { |type| type.interfaces(ctx).include?(int_type) }.sort_by(&:name)
-          end
-        end
-      end
-
-      def possible_types(type_defn, ctx)
-        case type_defn
-        when Module
-          possible_types(type_defn.graphql_definition, ctx)
-        when GraphQL::UnionType
-          type_defn.possible_types(ctx)
-        when GraphQL::InterfaceType
-          interface_implementers(ctx, type_defn)
-        when GraphQL::BaseType
-          [type_defn]
-        else
-          raise "Unexpected possible_types object: #{type_defn.inspect}"
-        end
-      end
-
-      def interface_implementers(ctx, type_defn)
-        @interface_implementers[ctx][type_defn]
-      end
-    end
-  end
-end

data/lib/graphql/schema/rescue_middleware.rb

@@ -1,60 +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
-            result = handler.call(err)
-            case result
-            when String
-              return GraphQL::ExecutionError.new(result)
-            when GraphQL::ExecutionError
-              return result
-            end
-          end
-        }
-
-        raise(err)
-      end
-    end
-  end
-end

data/lib/graphql/schema/timeout_middleware.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-require "delegate"
-
-module GraphQL
-  class Schema
-    # This middleware will stop resolving new fields after `max_seconds` have elapsed.
-    # After the time has passed, any remaining fields will be `nil`, with errors added
-    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
-    # you'll get a partial response.
-    #
-    # You can provide a block which will be called with any timeout errors that occur.
-    #
-    # Note that this will stop a query _in between_ field resolutions, but
-    # it doesn't interrupt long-running `resolve` functions. Be sure to use
-    # timeout options for external connections. For more info, see
-    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
-    #
-    # @example Stop resolving fields after 2 seconds
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2)
-    #
-    # @example Notifying Bugsnag on a timeout
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware(max_seconds: 1.5) do |timeout_error, query|
-    #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
-    #   end
-    #
-    # @api deprecated
-    # @see Schema::Timeout
-    class TimeoutMiddleware
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
-      def initialize(max_seconds:, context_key: nil, &block)
-        @max_seconds = max_seconds
-        if context_key
-          GraphQL::Deprecation.warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
-        end
-        @error_handler = block
-      end
-
-      def call(parent_type, parent_object, field_definition, field_args, query_context)
-        ns = query_context.namespace(self.class)
-        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        timeout_at = ns[:timeout_at] ||= now + @max_seconds
-
-        if timeout_at < now
-          on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
-        else
-          yield
-        end
-      end
-
-      # This is called when a field _would_ be resolved, except that we're over the time limit.
-      # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
-      def on_timeout(parent_type, parent_object, field_definition, field_args, field_context)
-        err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
-        if @error_handler
-          query_proxy = TimeoutQueryProxy.new(field_context.query, field_context)
-          @error_handler.call(err, query_proxy)
-        end
-        err
-      end
-
-      # This behaves like {GraphQL::Query} but {#context} returns
-      # the _field-level_ context, not the query-level context.
-      # This means you can reliably get the `irep_node` and `path`
-      # from it after the fact.
-      class TimeoutQueryProxy < SimpleDelegator
-        def initialize(query, ctx)
-          @context = ctx
-          super(query)
-        end
-
-        attr_reader :context
-      end
-
-      # This error is raised when a query exceeds `max_seconds`.
-      # Since it's a child of {GraphQL::ExecutionError},
-      # its message will be added to the response's `errors` key.
-      #
-      # To raise an error that will stop query resolution, use a custom block
-      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
-      # such as `RuntimeError`.
-      class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field_defn)
-          super("Timeout on #{parent_type.name}.#{field_defn.name}")
-        end
-      end
-    end
-  end
-end