graphql 1.9.5 → 1.13.19

data/lib/graphql/define/instance_definable.rb

@@ -1,119 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # This module provides the `.define { ... }` API for
-    # {GraphQL::BaseType}, {GraphQL::Field} and others.
-    #
-    # Calling `.accepts_definitions(...)` creates:
-    #
-    # - a keyword to the `.define` method
-    # - a helper method in the `.define { ... }` block
-    #
-    # The `.define { ... }` block will be called lazily. To be sure it has been
-    # called, use the private method `#ensure_defined`. That will call the
-    # definition block if it hasn't been called already.
-    #
-    # The goals are:
-    #
-    # - Minimal overhead in consuming classes
-    # - Independence between consuming classes
-    # - Extendable by third-party libraries without monkey-patching or other nastiness
-    #
-    # @example Make a class definable
-    #   class Car
-    #     include GraphQL::Define::InstanceDefinable
-    #     attr_accessor :make, :model, :doors
-    #     accepts_definitions(
-    #       # These attrs will be defined with plain setters, `{attr}=`
-    #       :make, :model,
-    #       # This attr has a custom definition which applies the config to the target
-    #       doors: ->(car, doors_count) { doors_count.times { car.doors << Door.new } }
-    #     )
-    #     ensure_defined(:make, :model, :doors)
-    #
-    #     def initialize
-    #       @doors = []
-    #     end
-    #   end
-    #
-    #   class Door; end;
-    #
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # The custom proc was applied:
-    #   subaru_baja.doors #=> [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Extending the definition of a class
-    #   # Add some definitions:
-    #   Car.accepts_definitions(all_wheel_drive: GraphQL::Define.assign_metadata_key(:all_wheel_drive))
-    #
-    #   # Use it in a definition
-    #   subaru_baja = Car.define do
-    #     # ...
-    #     all_wheel_drive true
-    #   end
-    #
-    #   # Access it from metadata
-    #   subaru_baja.metadata[:all_wheel_drive] # => true
-    #
-    # @example Extending the definition of a class via a plugin
-    #   # A plugin is any object that responds to `.use(definition)`
-    #   module SubaruCar
-    #     extend self
-    #
-    #     def use(defn)
-    #       # `defn` has the same methods as within `.define { ... }` block
-    #       defn.make "Subaru"
-    #       defn.doors 4
-    #     end
-    #   end
-    #
-    #   # Use the plugin within a `.define { ... }` block
-    #   subaru_baja = Car.define do
-    #     use SubaruCar
-    #     model 'Baja'
-    #   end
-    #
-    #   subaru_baja.make # => "Subaru"
-    #   subaru_baja.doors # => [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Making a copy with an extended definition
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # Then extend it with `#redefine`
-    #   two_door_baja = subaru_baja.redefine do
-    #     doors 2
-    #   end
+    # @api deprecated
     module InstanceDefinable
+      module DeprecatedDefine
+        def define(**kwargs, &block)
+          deprecated_caller = caller(1, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.define will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_define(**kwargs, &block)
+        end
+      end
+
       def self.included(base)
         base.extend(ClassMethods)
         base.ensure_defined(:metadata)
       end
 
-      # `metadata` can store arbitrary key-values with an object.
-      #
-      # @return [Hash<Object, Object>] Hash for user-defined storage
+      # @api deprecated
       def metadata
         @metadata ||= {}
       end
 
-      # Mutate this instance using functions from its {.definition}s.
-      # Keywords or helpers in the block correspond to keys given to `accepts_definitions`.
-      #
-      # Note that the block is not called right away -- instead, it's deferred until
-      # one of the defined fields is needed.
-      # @return [void]
-      def define(**kwargs, &block)
+      # @api deprecated
+      def deprecated_define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
         stash_dependent_methods
@@ -121,13 +39,16 @@ module GraphQL
         nil
       end
 
-      # Shallow-copy this object, then apply new definitions to the copy.
-      # @see {#define} for arguments
-      # @return [InstanceDefinable] A new instance, with any extended definitions
+      # @api deprecated
+      def define(**kwargs, &block)
+        deprecated_define(**kwargs, &block)
+      end
+
+      # @api deprecated
       def redefine(**kwargs, &block)
         ensure_defined
         new_inst = self.dup
-        new_inst.define(**kwargs, &block)
+        new_inst.deprecated_define(**kwargs, &block)
         new_inst
       end
 
@@ -154,7 +75,12 @@ module GraphQL
             defn_proxy = DefinedObjectProxy.new(self)
             # Apply definition from `define(...)` kwargs
             defn.define_keywords.each do |keyword, value|
-              defn_proxy.public_send(keyword, value)
+              # Don't splat string hashes, which blows up on Rubies before 2.7
+              if value.is_a?(Hash) && !value.empty? && value.each_key.all? { |k| k.is_a?(Symbol) }
+                defn_proxy.public_send(keyword, **value)
+              else
+                defn_proxy.public_send(keyword, value)
+              end
             end
             # and/or apply definition from `define { ... }` block
             if defn.define_proc
@@ -221,8 +147,16 @@ module GraphQL
       module ClassMethods
         # Create a new instance
         # and prepare a definition using its {.definitions}.
+        # @api deprecated
         # @param kwargs [Hash] Key-value pairs corresponding to defininitions from `accepts_definitions`
         # @param block [Proc] Block which calls helper methods from `accepts_definitions`
+        def deprecated_define(**kwargs, &block)
+          instance = self.new
+          instance.deprecated_define(**kwargs, &block)
+          instance
+        end
+
+        # @api deprecated
         def define(**kwargs, &block)
           instance = self.new
           instance.define(**kwargs, &block)
@@ -233,6 +167,21 @@ module GraphQL
         # Each symbol in `accepts` will be assigned with `{key}=`.
         # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
         def accepts_definitions(*accepts)
+          deprecated_caller = caller(0, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.accepts_definitions will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_accepts_definitions(*accepts)
+        end
+
+        def deprecated_accepts_definitions(*accepts)
           new_assignments = if accepts.last.is_a?(Hash)
             accepts.pop.dup
           else
@@ -287,13 +236,19 @@ module GraphQL
       end
 
       class AssignAttribute
+        extend GraphQL::Ruby2Keywords
+
         def initialize(attr_name)
           @attr_assign_method = :"#{attr_name}="
         end
 
-        def call(defn, value)
-          defn.public_send(@attr_assign_method, value)
+        # Even though we're just using the first value here,
+        # We have to add a splat here to use `ruby2_keywords`,
+        # so that it will accept a `[{}]` input from the caller.
+        def call(defn, *value)
+          defn.public_send(@attr_assign_method, value.first)
         end
+        ruby2_keywords :call
       end
     end
   end

data/lib/graphql/define/type_definer.rb

@@ -7,11 +7,11 @@ module GraphQL
     class TypeDefiner
       include Singleton
       # rubocop:disable Naming/MethodName
-      def Int;      GraphQL::INT_TYPE;      end
-      def String;   GraphQL::STRING_TYPE;   end
-      def Float;    GraphQL::FLOAT_TYPE;    end
-      def Boolean;  GraphQL::BOOLEAN_TYPE;  end
-      def ID;       GraphQL::ID_TYPE;       end
+      def Int;      GraphQL::DEPRECATED_INT_TYPE;      end
+      def String;   GraphQL::DEPRECATED_STRING_TYPE;   end
+      def Float;    GraphQL::DEPRECATED_FLOAT_TYPE;    end
+      def Boolean;  GraphQL::DEPRECATED_BOOLEAN_TYPE;  end
+      def ID;       GraphQL::DEPRECATED_ID_TYPE;       end
       # rubocop:enable Naming/MethodName
 
       # Make a {ListType} which wraps the input type

data/lib/graphql/deprecated_dsl.rb

@@ -4,13 +4,13 @@ module GraphQL
   #
   # 1. Scoped by file (CRuby only), add to the top of the file:
   #
-  #      using GraphQL::DeprecatedDSL
+  #      using GraphQL::DeprecationDSL
   #
   #   (This is a "refinement", there are also other ways to scope it.)
   #
   # 2. Global application, add before schema definition:
   #
-  #      GraphQL::DeprecatedDSL.activate
+  #      GraphQL::DeprecationDSL.activate
   #
   module DeprecatedDSL
     TYPE_CLASSES = [
@@ -23,19 +23,32 @@ module GraphQL
     ]
 
     def self.activate
+      deprecated_caller = caller(1, 1).first
+      GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` and remove `.activate` from #{deprecated_caller}"
       TYPE_CLASSES.each { |c| c.extend(Methods) }
       GraphQL::Schema::List.include(Methods)
       GraphQL::Schema::NonNull.include(Methods)
     end
+
     module Methods
       def !
+        deprecated_caller = caller(1, 1).first
+        GraphQL::Deprecation.warn "DeprecatedDSL will be removed from GraphQL-Ruby 2.0, use `.to_non_null_type` instead of `!` at #{deprecated_caller}"
         to_non_null_type
       end
     end
 
-    TYPE_CLASSES.each do |type_class|
-      refine type_class.singleton_class do
-        include Methods
+    if defined?(::Refinement) && Refinement.private_method_defined?(:import_methods)
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          import_methods Methods
+        end
+      end
+    else
+      TYPE_CLASSES.each do |type_class|
+        refine type_class.singleton_class do
+          include Methods
+        end
       end
     end
   end

data/lib/graphql/deprecation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Deprecation
+    def self.warn(message)
+      Kernel.warn(message)
+    end
+  end
+end

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,13 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Directive.define do
-  name "deprecated"
-  description "Marks an element of a GraphQL schema as no longer supported."
-  locations([GraphQL::Directive::FIELD_DEFINITION, GraphQL::Directive::ENUM_VALUE])
-
-  reason_description = "Explains why this element was deprecated, usually also including a "\
-    "suggestion for how to access supported similar data. Formatted "\
-    "in [Markdown](https://daringfireball.net/projects/markdown/)."
-
-  argument :reason, GraphQL::STRING_TYPE, reason_description, default_value: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-  default_directive true
-end
+GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/include_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive/skip_directive.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/directive.rb

@@ -8,7 +8,7 @@ module GraphQL
   #
   class Directive
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
+    deprecated_accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
 
     attr_accessor :locations, :arguments, :name, :description, :arguments_class
     attr_accessor :ast_node
@@ -45,7 +45,6 @@ module GraphQL
       INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
     ]
 
-    DEFAULT_DEPRECATION_REASON = 'No longer supported'
     LOCATION_DESCRIPTIONS = {
       QUERY:                    'Location adjacent to a query operation.',
       MUTATION:                 'Location adjacent to a mutation operation.',
@@ -96,9 +95,13 @@ module GraphQL
     def inspect
       "#<GraphQL::Directive #{name}>"
     end
+
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
   end
 end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -1,78 +1,10 @@
 # frozen_string_literal: true
 module GraphQL
-  # Represents a collection of related values.
-  # By convention, enum names are `SCREAMING_CASE_NAMES`,
-  # but other identifiers are supported too.
-  #
-  # You can use as return types _or_ as inputs.
-  #
-  # By default, enums are passed to `resolve` functions as
-  # the strings that identify them, but you can provide a
-  # custom Ruby value with the `value:` keyword.
-  #
-  # @example An enum of programming languages
-  #   LanguageEnum = GraphQL::EnumType.define do
-  #     name "Language"
-  #     description "Programming language for Web projects"
-  #     value("PYTHON", "A dynamic, function-oriented language")
-  #     value("RUBY", "A very dynamic language aimed at programmer happiness")
-  #     value("JAVASCRIPT", "Accidental lingua franca of the web")
-  #   end
-  #
-  # @example Using an enum as a return type
-  #    field :favoriteLanguage, LanguageEnum, "This person's favorite coding language"
-  #    # ...
-  #    # In a query:
-  #    Schema.execute("{ coder(id: 1) { favoriteLanguage } }")
-  #    # { "data" => { "coder" => { "favoriteLanguage" => "RUBY" } } }
-  #
-  # @example Defining an enum input
-  #    field :coders, types[CoderType] do
-  #      argument :knowing, types[LanguageEnum]
-  #      resolve ->(obj, args, ctx) {
-  #        Coder.where(language: args[:knowing])
-  #      }
-  #    end
-  #
-  # @example Using an enum as input
-  #   {
-  #     # find coders who know Python and Ruby
-  #     coders(knowing: [PYTHON, RUBY]) {
-  #       name
-  #       hourlyRate
-  #     }
-  #   }
-  #
-  # @example Enum whose values are different in Ruby-land
-  #   GraphQL::EnumType.define do
-  #     # ...
-  #     # use the `value:` keyword:
-  #     value("RUBY", "Lisp? Smalltalk?", value: :rb)
-  #   end
-  #
-  #   # Now, resolve functions will receive `:rb` instead of `"RUBY"`
-  #   field :favoriteLanguage, LanguageEnum
-  #   resolve ->(obj, args, ctx) {
-  #     args[:favoriteLanguage] # => :rb
-  #   }
-  #
-  # @example Enum whose values are different in ActiveRecord-land
-  #   class Language < ActiveRecord::Base
-  #     enum language: {
-  #       rb: 0
-  #     }
-  #   end
-  #
-  #   # Now enum type should be defined as
-  #   GraphQL::EnumType.define do
-  #     # ...
-  #     # use the `value:` keyword:
-  #     value("RUBY", "Lisp? Smalltalk?", value: 'rb')
-  #   end
-  #
-
+  # @api deprecated
   class EnumType < GraphQL::BaseType
-    accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
     attr_accessor :ast_node
 
@@ -102,10 +34,14 @@ module GraphQL
     end
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
-    def values
+    def values(_context = nil)
       @values_by_name
     end
 
+    def enum_values(_context = nil)
+      values.values
+    end
+
     def kind
       GraphQL::TypeKinds::ENUM
     end
@@ -136,7 +72,7 @@ module GraphQL
     class EnumValue
       include GraphQL::Define::InstanceDefinable
       ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
-      accepts_definitions(*ATTRIBUTES)
+      deprecated_accepts_definitions(*ATTRIBUTES)
       attr_accessor(*ATTRIBUTES)
       attr_accessor :ast_node
       ensure_defined(*ATTRIBUTES)
@@ -151,6 +87,10 @@ module GraphQL
       def graphql_name
         name
       end
+
+      def type_class
+        metadata[:type_class]
+      end
     end
 
     class UnresolvedValueError < GraphQL::Error

data/lib/graphql/execution/directive_checks.rb

@@ -18,12 +18,12 @@ module GraphQL
           case name
           when SKIP
             args = query.arguments_for(directive_ast_node, directive_defn)
-            if args['if'] == true
+            if args[:if] == true
               return false
             end
           when INCLUDE
             args = query.arguments_for(directive_ast_node, directive_defn)
-            if args['if'] == false
+            if args[:if] == false
               return false
             end
           else

data/lib/graphql/execution/errors.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    # A plugin that wraps query execution with error handling.
+    # Supports class-based schemas and the new {Interpreter} runtime only.
+    #
+    # @example Handling ActiveRecord::NotFound
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Execution::Errors
+    #
+    #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
+    #       ErrorTracker.log("Not Found: #{err.message}")
+    #       nil
+    #     end
+    #   end
+    #
+    class Errors
+      def self.use(schema)
+        definition_line = caller(2, 1).first
+        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
+      end
+
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
+      def initialize(schema)
+        @schema = schema
+        @handlers = {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
+      end
+
+      # @api private
+      def each_rescue
+        handlers = @handlers.values
+        while (handler = handlers.shift) do
+          yield(handler[:class], handler[:handler])
+          handlers.concat(handler[:subclass_handlers].values)
+        end
+      end
+
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handler [Proc]
+      # @return [void]
+      def rescue_from(error_class, error_handler)
+        subclasses_handlers = {}
+        this_level_subclasses = []
+        # During this traversal, do two things:
+        # - Identify any already-registered subclasses of this error class
+        #   and gather them up to be inserted _under_ this class
+        # - Find the point in the index where this handler should be inserted
+        #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
+        handlers = @handlers[:subclass_handlers]
+        while (handlers) do
+          this_level_subclasses.clear
+          # First, identify already-loaded handlers that belong
+          # _under_ this one. (That is, they're handlers
+          # for subclasses of `error_class`.)
+          handlers.each do |err_class, handler|
+            if err_class < error_class
+              subclasses_handlers[err_class] = handler
+              this_level_subclasses << err_class
+            end
+          end
+          # Any handlers that we'll be moving, delete them from this point in the index
+          this_level_subclasses.each do |err_class|
+            handlers.delete(err_class)
+          end
+
+          # See if any keys in this hash are superclasses of this new class:
+          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          if next_index_point
+            handlers = next_index_point[1][:subclass_handlers]
+          else
+            # this new handler doesn't belong to any sub-handlers,
+            # so insert it in the current set of `handlers`
+            break
+          end
+        end
+        # Having found the point at which to insert this handler,
+        # register it and merge any subclass handlers back in at this point.
+        this_class_handlers = handlers[error_class]
+        this_class_handlers[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
+      end
+
+      # Call the given block with the schema's configured error handlers.
+      #
+      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
+      #
+      # @param ctx [GraphQL::Query::Context]
+      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
+      def with_error_handling(ctx)
+        yield
+      rescue StandardError => err
+        handler = find_handler_for(err.class)
+        if handler
+          runtime_info = ctx.namespace(:interpreter) || {}
+          obj = runtime_info[:current_object]
+          args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
+          field = runtime_info[:current_field]
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          handler[:handler].call(err, obj, args, ctx, field)
+        else
+          raise err
+        end
+      end
+
+      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      def find_handler_for(error_class)
+        handlers = @handlers[:subclass_handlers]
+        handler = nil
+        while (handlers) do
+          _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
+          if next_handler
+            handlers = next_handler[:subclass_handlers]
+            handler = next_handler
+          else
+            # Don't reassign `handler` --
+            # let the previous assignment carry over outside this block.
+            break
+          end
+        end
+
+        # check for a handler from a parent class:
+        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
+          parent_handler = parent_errors.find_handler_for(error_class)
+        end
+
+        # If the inherited handler is more specific than the one defined here,
+        # use it.
+        # If it's a tie (or there is no parent handler), use the one defined here.
+        # If there's an inherited one, but not one defined here, use the inherited one.
+        # Otherwise, there's no handler for this error, return `nil`.
+        if parent_handler && handler && parent_handler[:class] < handler[:class]
+          parent_handler
+        elsif handler
+          handler
+        elsif parent_handler
+          parent_handler
+        else
+          nil
+        end
+      end
+    end
+  end
+end