graphql 1.8.7 → 1.9.0

data/lib/graphql/analysis/ast.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "graphql/analysis/ast/visitor"
+require "graphql/analysis/ast/analyzer"
+require "graphql/analysis/ast/field_usage"
+require "graphql/analysis/ast/query_complexity"
+require "graphql/analysis/ast/max_query_complexity"
+require "graphql/analysis/ast/query_depth"
+require "graphql/analysis/ast/max_query_depth"
+
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      module_function
+
+      def use(schema_defn)
+        schema = schema_defn.target
+        schema.analysis_engine = GraphQL::Analysis::AST
+      end
+
+      # Analyze a multiplex, and all queries within.
+      # Multiplex analyzers are ran for all queries, keeping state.
+      # Query analyzers are ran per query, without carrying state between queries.
+      #
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
+      # @return [void]
+      def analyze_multiplex(multiplex, analyzers)
+        multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
+
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
+          query_results = multiplex.queries.map do |query|
+            if query.valid?
+              analyze_query(
+                query,
+                query.analyzers,
+                multiplex_analyzers: multiplex_analyzers
+              )
+            else
+              []
+            end
+          end
+
+          multiplex_results = multiplex_analyzers.map(&:result)
+          multiplex_errors = analysis_errors(multiplex_results)
+
+          multiplex.queries.each_with_index do |query, idx|
+            query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+          end
+        end
+        nil
+      end
+
+      # @param query [GraphQL::Query]
+      # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
+      # @return [Array<Any>] Results from those analyzers
+      def analyze_query(query, analyzers, multiplex_analyzers: [])
+        query.trace("analyze_query", { query: query }) do
+          query_analyzers = analyzers
+            .map { |analyzer| analyzer.new(query) }
+            .select { |analyzer| analyzer.analyze? }
+
+          analyzers_to_run = query_analyzers + multiplex_analyzers
+          return [] unless analyzers_to_run.any?
+
+          visitor = GraphQL::Analysis::AST::Visitor.new(
+            query: query,
+            analyzers: analyzers_to_run
+          )
+
+          visitor.visit
+
+          query_analyzers.map(&:result)
+        end
+      end
+
+      def analysis_errors(results)
+        results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
+      end
+    end
+  end
+end

data/lib/graphql/analysis.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/analysis/ast"
 require "graphql/analysis/max_query_complexity"
 require "graphql/analysis/max_query_depth"
 require "graphql/analysis/query_complexity"

data/lib/graphql/argument.rb

@@ -89,6 +89,11 @@ module GraphQL
       @expose_as ||= (@as || @name).to_s
     end
 
+    # Backport this to support legacy-style directives
+    def keyword
+      @keyword ||= GraphQL::Schema::Member::BuildType.underscore(expose_as).to_sym
+    end
+
     # @param value [Object] The incoming value from variables or query string literal
     # @param ctx [GraphQL::Query::Context]
     # @return [Object] The prepared `value` for this argument or `value` itself if no `prepare` function exists.

data/lib/graphql/authorization.rb

@@ -20,6 +20,7 @@ module GraphQL
       end
     end
 
+    # @deprecated authorization at query runtime is generally a better idea.
     module Analyzer
       module_function
       def initial_value(query)

data/lib/graphql/backwards_compatibility.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  # Helpers for migrating in a backwards-compatibile way
+  # Helpers for migrating in a backwards-compatible way
   # @api private
   module BackwardsCompatibility
     module_function

data/lib/graphql/base_type.rb

@@ -187,7 +187,7 @@ module GraphQL
         resolve_related_type(type_arg.call)
       when String
         # Get a constant by this name
-        Object.const_get(type_arg)
+        resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
           type_arg.graphql_definition

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -49,8 +49,7 @@ module GraphQL
         end
 
         module TestMiddleware
-          # TODO: Once deprecated `next_middleware` argument becomes unsupported, add `&` to the argument
-          def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+          def self.call(parent_type, parent_object, field_definition, field_args, query_context, &next_middleware)
             query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
             next_middleware.call
           end

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -595,31 +595,27 @@ module GraphQL
 
             assert_equal 6, document.definitions.size
 
-            schema_definition = document.definitions.shift
+            schema_definition, directive_definition, enum_type_definition, object_type_definition, input_object_type_definition, interface_type_definition = document.definitions
+
             assert_equal GraphQL::Language::Nodes::SchemaDefinition, schema_definition.class
 
-            directive_definition = document.definitions.shift
             assert_equal GraphQL::Language::Nodes::DirectiveDefinition, directive_definition.class
             assert_equal 'This is a directive', directive_definition.description
 
-            enum_type_definition = document.definitions.shift
             assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, enum_type_definition.class
             assert_equal "Multiline comment\n\nWith an enum", enum_type_definition.description
 
             assert_nil enum_type_definition.values[0].description
             assert_equal 'Not a creative color', enum_type_definition.values[1].description
 
-            object_type_definition = document.definitions.shift
             assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, object_type_definition.class
             assert_equal 'Comment without preceding space', object_type_definition.description
             assert_equal 'And a field to boot', object_type_definition.fields[0].description
 
-            input_object_type_definition = document.definitions.shift
             assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, input_object_type_definition.class
             assert_equal 'Comment for input object types', input_object_type_definition.description
             assert_equal 'Color of the car', input_object_type_definition.fields[0].description
 
-            interface_type_definition = document.definitions.shift
             assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, interface_type_definition.class
             assert_equal 'Comment for interface definitions', interface_type_definition.description
             assert_equal 'Amount of wheels', interface_type_definition.fields[0].description

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/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,
@@ -84,6 +92,10 @@ module GraphQL
     def default_directive?
       @default_directive
     end
+
+    def inspect
+      "#<GraphQL::Directive #{name}>"
+    end
   end
 end
 

data/lib/graphql/enum_type.rb

@@ -147,6 +147,10 @@ module GraphQL
         GraphQL::NameValidator.validate!(new_name)
         @name = new_name
       end
+
+      def graphql_name
+        name
+      end
     end
 
     class UnresolvedValueError < GraphQL::Error
@@ -165,6 +169,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/execute.rb

@@ -24,6 +24,23 @@ module GraphQL
         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
@@ -142,11 +159,11 @@ module GraphQL
         # If the returned object is finished, continue to coerce
         # and resolve child fields
         def continue_or_wait(raw_value, field_type, field_ctx)
-          if (lazy_method = field_ctx.schema.lazy_method_name(raw_value))
+          if field_ctx.schema.lazy?(raw_value)
             field_ctx.value = Execution::Lazy.new {
               inner_value = begin
                   begin
-                    raw_value.public_send(lazy_method)
+                    field_ctx.schema.sync_lazy(raw_value)
                   rescue GraphQL::UnauthorizedError => err
                     field_ctx.schema.unauthorized_object(err)
                   end
@@ -179,7 +196,7 @@ module GraphQL
               if list_errors.any?
                 list_errors.each do |error, index|
                   error.ast_node = field_ctx.ast_node
-                  error.path = field_ctx.path + [index]
+                  error.path = field_ctx.path + (field_ctx.type.list? ? [index] : [])
                   query.context.errors.push(error)
                 end
               end
@@ -264,20 +281,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}")

data/lib/graphql/execution/instrumentation.rb

@@ -62,6 +62,8 @@ module GraphQL
             # if any before hooks raise an exception, quit calling before hooks,
             # but call the after hooks on anything that succeeded but also
             # raise the exception that came from the before hook.
+          rescue GraphQL::ExecutionError => err
+            object.context.errors << err
           rescue => e
             raise call_after_hooks(successful, object, after_hook_name, e)
           end

data/lib/graphql/execution/interpreter/execution_errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class ExecutionErrors
+        def initialize(ctx, ast_node, path)
+          @context = ctx
+          @ast_node = ast_node
+          @path = path
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          err.ast_node ||= @ast_node
+          err.path ||= @path
+          @context.add_error(err)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/interpreter/hash_response.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      # This response class handles `#write` by accumulating
+      # values into a Hash.
+      class HashResponse
+        def initialize
+          @result = {}
+        end
+
+        def final_value
+          @result
+        end
+
+        def inspect
+          "#<#{self.class.name} result=#{@result.inspect}>"
+        end
+
+        # Add `value` at `path`.
+        # @return [void]
+        def write(path, value)
+          if path.empty?
+            @result = value
+          elsif (write_target = @result)
+            i = 0
+            prefinal_steps = path.size - 1
+            # Use `while` to avoid a closure
+            while i < prefinal_steps
+              path_part = path[i]
+              i += 1
+              write_target = write_target[path_part]
+            end
+            path_part = path[i]
+            write_target[path_part] = value
+          else
+            # The response is completely nulled out
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/interpreter/resolve.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      module Resolve
+        # Continue field results in `results` until there's nothing else to continue.
+        # @return [void]
+        def self.resolve_all(results)
+          while results.any?
+            results = resolve(results)
+          end
+        end
+
+        # After getting `results` back from an interpreter evaluation,
+        # continue it until you get a response-ready Ruby value.
+        #
+        # `results` is one level of _depth_ of a query or multiplex.
+        #
+        # Resolve all lazy values in that depth before moving on
+        # to the next level.
+        #
+        # It's assumed that the lazies will
+        # return {Lazy} instances if there's more work to be done,
+        # or return {Hash}/{Array} if the query should be continued.
+        #
+        # @param results [Array]
+        # @return [Array] Same size, filled with finished values
+        def self.resolve(results)
+          next_results = []
+
+          # Work through the queue until it's empty
+          while results.size > 0
+            result_value = results.shift
+
+            if result_value.is_a?(Lazy)
+              result_value = result_value.value
+            end
+
+            if result_value.is_a?(Lazy)
+              # Since this field returned another lazy,
+              # add it to the same queue
+              results << result_value
+            elsif result_value.is_a?(Hash)
+              # This is part of the next level, add it
+              next_results.concat(result_value.values)
+            elsif result_value.is_a?(Array)
+              # This is part of the next level, add it
+              next_results.concat(result_value)
+            end
+          end
+
+          next_results
+        end
+      end
+    end
+  end
+end