graphql 1.8.0 → 1.12.12

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,12 +23,17 @@ 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

data/lib/graphql/deprecation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Deprecation
+    def self.warn(message)
+      if defined?(ActiveSupport::Deprecation)
+        ActiveSupport::Deprecation.warn(message)
+      else
+        Kernel.warn(message)
+      end
+    end
+  end
+end

data/lib/graphql/dig.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  module Dig
+    # implemented using the old activesupport #dig instead of the ruby built-in
+    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # to handle stringified/symbolized keys.
+    #
+    # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
+    # @return [Object]
+    def dig(own_key, *rest_keys)
+      val = self[own_key]
+      if val.nil? || rest_keys.empty?
+        val
+      else
+        val.dig(*rest_keys)
+      end
+    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

data/lib/graphql/directive/include_directive.rb

@@ -1,8 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
-  name "include"
-  description "Directs the executor to include this field or fragment only when the `if` argument is true."
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-  argument :if, !GraphQL::BOOLEAN_TYPE, 'Included when true.'
-  default_directive true
-end
+GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition

data/lib/graphql/directive/skip_directive.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
-  name "skip"
-  description "Directs the executor to skip this field or fragment when the `if` argument is true."
-  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
-
-  argument :if, !GraphQL::BOOLEAN_TYPE, 'Skipped when true.'
-  default_directive true
-end
+GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition

data/lib/graphql/directive.rb

@@ -14,7 +14,15 @@ module GraphQL
     attr_accessor :ast_node
     # @api private
     attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :name, :description, :default_directive?)
+    ensure_defined(:locations, :arguments, :graphql_name, :name, :description, :default_directive?)
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
 
     LOCATIONS = [
       QUERY =                  :QUERY,
@@ -37,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.',
@@ -84,6 +91,18 @@ module GraphQL
     def default_directive?
       @default_directive
     end
+
+    def inspect
+      "#<GraphQL::Directive #{name}>"
+    end
+
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
   end
 end
 

data/lib/graphql/enum_type.rb

@@ -1,77 +1,9 @@
 # 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 "Languages"
-  #     description "Programming languages 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::BaseType
-  #     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
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
     attr_accessor :ast_node
@@ -141,11 +73,20 @@ module GraphQL
       attr_accessor :ast_node
       ensure_defined(*ATTRIBUTES)
 
+      undef name=
       def name=(new_name)
         # Validate that the name is correct
         GraphQL::NameValidator.validate!(new_name)
         @name = new_name
       end
+
+      def graphql_name
+        name
+      end
+
+      def type_class
+        metadata[:type_class]
+      end
     end
 
     class UnresolvedValueError < GraphQL::Error
@@ -164,6 +105,10 @@ module GraphQL
     def coerce_non_null_input(value_name, ctx)
       if @values_by_name.key?(value_name)
         @values_by_name.fetch(value_name).value
+      elsif match_by_value = @values_by_name.find { |k, v| v.value == value_name }
+        # this is for matching default values, which are "inputs", but they're
+        # the Ruby value, not the GraphQL string.
+        match_by_value[1].value
       else
         nil
       end

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,162 @@
+# 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]
+          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

data/lib/graphql/execution/execute.rb

@@ -6,7 +6,7 @@ module GraphQL
     class Execute
 
       # @api private
-      class Skip; end
+      class Skip < GraphQL::Error; end
 
       # Just a singleton for implementing {Query::Context#skip}
       # @api private
@@ -18,12 +18,36 @@ module GraphQL
       # @api private
       PROPAGATE_NULL = PropagateNull.new
 
+      def self.use(schema_class)
+        schema_class.query_execution_strategy(self)
+        schema_class.mutation_execution_strategy(self)
+        schema_class.subscription_execution_strategy(self)
+      end
+
       def execute(ast_operation, root_type, query)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         result = resolve_root_selection(query)
-        lazy_resolve_root_selection(result, {query: query})
+        lazy_resolve_root_selection(result, **{query: query})
         GraphQL::Execution::Flatten.call(query.context)
       end
 
+      def self.begin_multiplex(_multiplex)
+      end
+
+      def self.begin_query(query, _multiplex)
+        ExecutionFunctions.resolve_root_selection(query)
+      end
+
+      def self.finish_multiplex(results, multiplex)
+        ExecutionFunctions.lazy_resolve_root_selection(results, multiplex: multiplex)
+      end
+
+      def self.finish_query(query, _multiplex)
+        {
+          "data" => Execution::Flatten.call(query.context)
+        }
+      end
+
       # @api private
       module ExecutionFunctions
         module_function
@@ -33,12 +57,16 @@ module GraphQL
             operation = query.selected_operation
             op_type = operation.operation_type
             root_type = query.root_type_for_operation(op_type)
-            resolve_selection(
-              query.root_value,
-              root_type,
-              query.context,
-              mutation: query.mutation?
-            )
+            if query.context[:__root_unauthorized]
+              # This was set by member/instrumentation.rb so that we wouldn't continue.
+            else
+              resolve_selection(
+                query.root_value,
+                root_type,
+                query.context,
+                mutation: query.mutation?
+              )
+            end
           end
         end
 
@@ -102,38 +130,69 @@ module GraphQL
           field = field_ctx.field
 
           raw_value = begin
-            arguments = query.arguments_for(irep_node, field)
-            field_ctx.trace("execute_field", { context: field_ctx }) do
-              field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+            begin
+              arguments = query.arguments_for(irep_node, field)
+              field_ctx.trace("execute_field", { context: field_ctx }) do
+                field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+              end
+            rescue GraphQL::UnauthorizedFieldError => err
+              err.field ||= field
+              field_ctx.schema.unauthorized_field(err)
+            rescue GraphQL::UnauthorizedError => err
+              field_ctx.schema.unauthorized_object(err)
             end
           rescue GraphQL::ExecutionError => err
             err
           end
 
-          # If the returned object is lazy (unfinished),
-          # assign the lazy object to `.value=` so we can resolve it later.
-          # When we resolve it later, reassign it to `.value=` so that
-          # the finished value replaces the unfinished one.
-          #
-          # If the returned object is finished, continue to coerce
-          # and resolve child fields
-          if query.schema.lazy?(raw_value)
+          if field_ctx.schema.lazy?(raw_value)
             field_ctx.value = Execution::Lazy.new {
               inner_value = field_ctx.trace("execute_field_lazy", {context: field_ctx}) {
                 begin
-                  field.lazy_resolve(raw_value, arguments, field_ctx)
+                  begin
+                    field_ctx.field.lazy_resolve(raw_value, arguments, field_ctx)
+                  rescue GraphQL::UnauthorizedError => err
+                    field_ctx.schema.unauthorized_object(err)
+                  end
                 rescue GraphQL::ExecutionError => err
                   err
                 end
               }
-              field_ctx.value = continue_resolve_field(inner_value, field_ctx)
+              continue_or_wait(inner_value, field_ctx.type, field_ctx)
             }
           else
-            field_ctx.value = continue_resolve_field(raw_value, field_ctx)
+            continue_or_wait(raw_value, field_ctx.type, field_ctx)
           end
         end
 
-        def continue_resolve_field(raw_value, field_ctx)
+        # If the returned object is lazy (unfinished),
+        # assign the lazy object to `.value=` so we can resolve it later.
+        # When we resolve it later, reassign it to `.value=` so that
+        # the finished value replaces the unfinished one.
+        #
+        # If the returned object is finished, continue to coerce
+        # and resolve child fields
+        def continue_or_wait(raw_value, field_type, field_ctx)
+          if field_ctx.schema.lazy?(raw_value)
+            field_ctx.value = Execution::Lazy.new {
+              inner_value = begin
+                  begin
+                    field_ctx.schema.sync_lazy(raw_value)
+                  rescue GraphQL::UnauthorizedError => err
+                    field_ctx.schema.unauthorized_object(err)
+                  end
+                rescue GraphQL::ExecutionError => err
+                  err
+                end
+
+              field_ctx.value = continue_or_wait(inner_value, field_type, field_ctx)
+            }
+          else
+            field_ctx.value = continue_resolve_field(raw_value, field_type, field_ctx)
+          end
+        end
+
+        def continue_resolve_field(raw_value, field_type, field_ctx)
           if field_ctx.parent.invalid_null?
             return nil
           end
@@ -145,19 +204,22 @@ module GraphQL
             raw_value.path = field_ctx.path
             query.context.errors.push(raw_value)
           when Array
-            list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
-            if list_errors.any?
-              list_errors.each do |error, index|
-                error.ast_node = field_ctx.ast_node
-                error.path = field_ctx.path + [index]
-                query.context.errors.push(error)
+            if field_type.non_null?
+              # List type errors are handled above, this is for the case of fields returning an array of errors
+              list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
+              if list_errors.any?
+                list_errors.each do |error, index|
+                  error.ast_node = field_ctx.ast_node
+                  error.path = field_ctx.path + (field_ctx.type.list? ? [index] : [])
+                  query.context.errors.push(error)
+                end
               end
             end
           end
 
           resolve_value(
             raw_value,
-            field_ctx.type,
+            field_type,
             field_ctx,
           )
         end
@@ -205,16 +267,18 @@ module GraphQL
                   irep_node: field_ctx.irep_node,
                 )
 
-                inner_result = resolve_value(
+                inner_result = continue_or_wait(
                   inner_value,
                   inner_type,
                   inner_ctx,
                 )
 
-                inner_ctx.value = inner_result
+                return PROPAGATE_NULL if inner_result == PROPAGATE_NULL
+
                 result << inner_ctx
                 i += 1
               end
+
               result
             when GraphQL::TypeKinds::NON_NULL
               inner_type = field_type.of_type
@@ -231,20 +295,22 @@ module GraphQL
               )
             when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
               query = field_ctx.query
-              resolved_type = field_type.resolve_type(value, field_ctx)
-              possible_types = query.possible_types(field_type)
-
-              if !possible_types.include?(resolved_type)
-                parent_type = field_ctx.irep_node.owner_type
-                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
-                field_ctx.schema.type_error(type_error, field_ctx)
-                PROPAGATE_NULL
-              else
-                resolve_value(
-                  value,
-                  resolved_type,
-                  field_ctx,
-                )
+              resolved_type_or_lazy = field_type.resolve_type(value, field_ctx)
+              query.schema.after_lazy(resolved_type_or_lazy) do |resolved_type|
+                possible_types = query.possible_types(field_type)
+
+                if !possible_types.include?(resolved_type)
+                  parent_type = field_ctx.irep_node.owner_type
+                  type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                  field_ctx.schema.type_error(type_error, field_ctx)
+                  PROPAGATE_NULL
+                else
+                  resolve_value(
+                    value,
+                    resolved_type,
+                    field_ctx,
+                  )
+                end
               end
             else
               raise("Unknown type kind: #{field_type.kind}")