graphql 1.7.6 → 1.8.0

data/lib/graphql/execution/execute.rb

@@ -68,12 +68,10 @@ module GraphQL
               irep_node: child_irep_node,
             )
 
-            field_result = field_ctx.trace("execute_field", { context: field_ctx }) do
-              resolve_field(
-                object,
-                field_ctx
-              )
-            end
+            field_result = resolve_field(
+              object,
+              field_ctx
+            )
 
             if field_result.is_a?(Skip)
               next
@@ -105,7 +103,9 @@ module GraphQL
 
           raw_value = begin
             arguments = query.arguments_for(irep_node, field)
-            field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+            field_ctx.trace("execute_field", { context: field_ctx }) do
+              field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+            end
           rescue GraphQL::ExecutionError => err
             err
           end
@@ -118,12 +118,14 @@ module GraphQL
           # If the returned object is finished, continue to coerce
           # and resolve child fields
           if query.schema.lazy?(raw_value)
-            field_ctx.value = field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
-              field_ctx.value = continue_resolve_field(inner_value, field_ctx)
-            }
-          elsif raw_value.is_a?(GraphQL::Execution::Lazy)
-            # It came from a connection resolve, assume it was already instrumented
-            field_ctx.value = raw_value.then { |inner_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)
+                rescue GraphQL::ExecutionError => err
+                  err
+                end
+              }
               field_ctx.value = continue_resolve_field(inner_value, field_ctx)
             }
           else
@@ -178,6 +180,12 @@ module GraphQL
             else
               nil
             end
+          elsif value.is_a?(Array) && value.any? && value.all? {|v| v.is_a?(GraphQL::ExecutionError)}
+            if field_type.kind.non_null?
+              PROPAGATE_NULL
+            else
+              nil
+            end
           elsif value.is_a?(Skip)
             field_ctx.value = value
           else

data/lib/graphql/execution/instrumentation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Instrumentation
+      # This function implements the instrumentation policy:
+      #
+      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
+      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
+      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
+      #
+      # When errors are raised from `after_` hooks:
+      #   - Subsequent `after_` hooks _are_ called
+      #   - The first raised error is captured; later errors are ignored
+      #   - If an error was capture, it's re-raised after all hooks are finished
+      #
+      # Partial runs of instrumentation are possible:
+      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
+      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
+      def self.apply_instrumenters(multiplex)
+        schema = multiplex.schema
+        queries = multiplex.queries
+        query_instrumenters = schema.instrumenters[:query]
+        multiplex_instrumenters = schema.instrumenters[:multiplex]
+
+        # First, run multiplex instrumentation, then query instrumentation for each query
+        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+          each_query_call_hooks(query_instrumenters, queries) do
+            # Let them be executed
+            yield
+          end
+        end
+      end
+
+      class << self
+        private
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
+        end
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name, i = 0)
+          if i >= instrumenters.length
+            # We've reached the end of the instrumenters, so start exiting the call stack.
+            # (This will eventually call the originally-passed block.)
+            yield
+          else
+            # Get the next instrumenter and call the before_hook.
+            instrumenter = instrumenters[i]
+            instrumenter.public_send(before_hook_name, object)
+            # At this point, the before_hook did _not_ raise an error.
+            # (If it did raise an error, we wouldn't reach this point.)
+            # So we should guarantee that we run the after_hook.
+            begin
+              # Call the next instrumenter on the list,
+              # basically passing along the original block
+              call_hooks(instrumenters, object, before_hook_name, after_hook_name, i + 1) {
+                yield
+              }
+            ensure
+              # Regardless of how the next instrumenter in the list behaves,
+              # call the after_hook of this instrumenter
+              instrumenter.public_send(after_hook_name, object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -51,7 +51,7 @@ module GraphQL
 
         # Mock the Concurrent::Map API
         class ConcurrentishMap
-          extend GraphQL::Delegate
+          extend Forwardable
           # Technically this should be under the mutex too,
           # but I know it's only used when the lock is already acquired.
           def_delegators :@storage, :each_pair, :size

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

@@ -37,9 +37,7 @@ module GraphQL
           else
             Lazy.new {
               acc.each_with_index { |ctx, idx|
-                acc[idx] = ctx.trace("execute_field_lazy", { context: ctx }) do
-                  ctx.value.value
-                end
+                acc[idx] = ctx.value.value
               }
               resolve_in_place(acc)
             }

data/lib/graphql/execution/multiplex.rb

@@ -60,12 +60,12 @@ module GraphQL
               if queries.length != 1
                 raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
               else
-                with_instrumentation(multiplex, max_complexity: max_complexity) do
+                instrument_and_analyze(multiplex, max_complexity: max_complexity) do
                   [run_one_legacy(schema, queries.first)]
                 end
               end
             else
-              with_instrumentation(multiplex, max_complexity: max_complexity) do
+              instrument_and_analyze(multiplex, max_complexity: max_complexity) do
                 run_as_multiplex(multiplex)
               end
             end
@@ -93,7 +93,7 @@ module GraphQL
           end
         rescue StandardError
           # Assign values here so that the query's `@executed` becomes true
-          queries.map { |q| q.result_values ||= nil }
+          queries.map { |q| q.result_values ||= {} }
           raise
         end
 
@@ -162,34 +162,17 @@ module GraphQL
         # Apply multiplex & query instrumentation to `queries`.
         #
         # It yields when the queries should be executed, then runs teardown.
-        def with_instrumentation(multiplex, max_complexity:)
-          schema = multiplex.schema
-          queries = multiplex.queries
-          query_instrumenters = schema.instrumenters[:query]
-          multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-          # First, run multiplex instrumentation, then query instrumentation for each query
-          multiplex_instrumenters.each { |i| i.before_multiplex(multiplex) }
-          queries.each do |query|
-            query_instrumenters.each { |i| i.before_query(query) }
-          end
-
-          multiplex_analyzers = schema.multiplex_analyzers
-          if max_complexity
-            multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
-          end
-
-          GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+        def instrument_and_analyze(multiplex, max_complexity:)
+          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
+            schema = multiplex.schema
+            multiplex_analyzers = schema.multiplex_analyzers
+            if max_complexity
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
+            end
 
-          # Let them be executed
-          yield
-        ensure
-          # Finally, run teardown instrumentation for each query + the multiplex
-          # Use `reverse_each` so instrumenters are treated like a stack
-          queries.each do |query|
-            query_instrumenters.reverse_each { |i| i.after_query(query) }
+            GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+            yield
           end
-          multiplex_instrumenters.reverse_each { |i| i.after_multiplex(multiplex) }
         end
       end
     end

data/lib/graphql/execution.rb

@@ -2,6 +2,7 @@
 require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
 require "graphql/execution/flatten"
+require "graphql/execution/instrumentation"
 require "graphql/execution/lazy"
 require "graphql/execution/multiplex"
 require "graphql/execution/typecast"

data/lib/graphql/field.rb

@@ -102,7 +102,7 @@ module GraphQL
   # @example Calculating the complexity of a list field
   #   field :items, types[ItemType] do
   #     argument :limit, !types.Int
-  #     # Mulitply the child complexity by the possible items on the list
+  #     # Multiply the child complexity by the possible items on the list
   #     complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }
   #   end
   #
@@ -130,6 +130,8 @@ module GraphQL
       :relay_node_field,
       :relay_nodes_field,
       :subscription_scope,
+      :trace,
+      :introspection,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
@@ -137,7 +139,8 @@ module GraphQL
       :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope
+      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope,
+      :introspection?
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -182,10 +185,16 @@ module GraphQL
     attr_accessor :arguments_class
 
     attr_writer :connection
+    attr_writer :introspection
 
     # @return [nil, String] Prefix for subscription names from this field
     attr_accessor :subscription_scope
 
+    # @return [Boolean] True if this field should be traced. By default, fields are only traced if they are not a ScalarType or EnumType.
+    attr_accessor :trace
+
+    attr_accessor :ast_node
+
     # @return [Boolean]
     def connection?
       @connection
@@ -212,13 +221,21 @@ module GraphQL
       @connection = false
       @connection_max_page_size = nil
       @edge_class = nil
+      @trace = nil
+      @introspection = false
     end
 
     def initialize_copy(other)
+      ensure_defined
       super
       @arguments = other.arguments.dup
     end
 
+    # @return [Boolean] Is this field a predefined introspection field?
+    def introspection?
+      @introspection
+    end
+
     # Get a value for this field
     # @example resolving a field value
     #   field.resolve(obj, args, ctx)
@@ -274,8 +291,8 @@ module GraphQL
       "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
     end
 
-    # If {#resolve} returned and object which should be handled lazily,
-    # this method will be called later force the object to return its value.
+    # If {#resolve} returned an object which should be handled lazily,
+    # this method will be called later to force the object to return its value.
     # @param obj [Object] The {#resolve}-provided object, registered with {Schema#lazy_resolve}
     # @param args [GraphQL::Query::Arguments] Arguments to this field
     # @param ctx [GraphQL::Query::Context] Context for this field

data/lib/graphql/function.rb

@@ -28,6 +28,8 @@ module GraphQL
   #     field :post, function: FindRecord.new(model: Post, type: PostType)
   #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
   #   end
+  #
+  # @see {GraphQL::Schema::Resolver} for a replacement for `GraphQL::Function`
   class Function
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments
@@ -97,6 +99,18 @@ module GraphQL
         end
       end
 
+      def build_field(function)
+        GraphQL::Field.define(
+          arguments: function.arguments,
+          complexity: function.complexity,
+          type: function.type,
+          resolve: function,
+          description: function.description,
+          function: function,
+          deprecation_reason: function.deprecation_reason,
+        )
+      end
+
       # Class-level reader/writer which is inherited
       # @api private
       def self.inherited_value(name)

data/lib/graphql/input_object_type.rb

@@ -84,6 +84,7 @@ module GraphQL
 
     def coerce_non_null_input(value, ctx)
       input_values = {}
+      defaults_used = Set.new
 
       arguments.each do |input_key, input_field_defn|
         field_value = value[input_key]
@@ -93,10 +94,11 @@ module GraphQL
           input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
         elsif input_field_defn.default_value?
           input_values[input_key] = input_field_defn.default_value
+          defaults_used << input_key
         end
       end
 
-      arguments_class.new(input_values)
+      arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
     end
 
     # @api private

data/lib/graphql/interface_type.rb

@@ -23,20 +23,22 @@ module GraphQL
   #   end
   #
   class InterfaceType < GraphQL::BaseType
-    accepts_definitions :fields, :resolve_type, field: GraphQL::Define::AssignObjectField
+    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
-    attr_accessor :fields, :resolve_type_proc
-    ensure_defined :fields, :resolve_type_proc, :resolve_type
+    attr_accessor :fields, :orphan_types, :resolve_type_proc
+    ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
 
     def initialize
       super
       @fields = {}
+      @orphan_types = []
       @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
       super
       @fields = other.fields.dup
+      @orphan_types = other.orphan_types.dup
     end
 
     def kind

data/lib/graphql/internal_representation/node.rb

@@ -4,6 +4,12 @@ module GraphQL
     class Node
       # @api private
       DEFAULT_TYPED_CHILDREN = Proc.new { |h, k| h[k] = {} }
+
+      # A specialized, reusable object for leaf nodes.
+      NO_TYPED_CHILDREN = Hash.new({}.freeze)
+      def NO_TYPED_CHILDREN.dup; self; end;
+      NO_TYPED_CHILDREN.freeze
+
       # @return [String] the name this node has in the response
       attr_reader :name
 
@@ -16,9 +22,9 @@ module GraphQL
       # This value is derived from {#scoped_children} after the rewrite is finished.
       # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
       def typed_children
-        @typed_childen ||= begin
-          new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
+        @typed_children ||= begin
           if @scoped_children.any?
+            new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
             all_object_types = Set.new
             scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
             # Remove any scoped children which don't follow this return type
@@ -27,8 +33,11 @@ module GraphQL
             all_object_types.each do |t|
               new_tc[t] = get_typed_children(t)
             end
+            new_tc
+          else
+            NO_TYPED_CHILDREN
           end
-          new_tc
+
         end
       end
 
@@ -125,17 +134,20 @@ module GraphQL
           @ast_nodes |= new_parent.ast_nodes
           @definitions |= new_parent.definitions
         end
-        scope ||= Scope.new(@query, @return_type.unwrap)
-        new_parent.scoped_children.each do |obj_type, new_fields|
-          inner_scope = scope.enter(obj_type)
-          inner_scope.each do |scoped_type|
-            prev_fields = @scoped_children[scoped_type]
-            new_fields.each do |name, new_node|
-              prev_node = prev_fields[name]
-              if prev_node
-                prev_node.deep_merge_node(new_node)
-              else
-                prev_fields[name] = new_node
+        new_sc = new_parent.scoped_children
+        if new_sc.any?
+          scope ||= Scope.new(@query, @return_type.unwrap)
+          new_sc.each do |obj_type, new_fields|
+            inner_scope = scope.enter(obj_type)
+            inner_scope.each do |scoped_type|
+              prev_fields = @scoped_children[scoped_type]
+              new_fields.each do |name, new_node|
+                prev_node = prev_fields[name]
+                if prev_node
+                  prev_node.deep_merge_node(new_node)
+                else
+                  prev_fields[name] = new_node
+                end
               end
             end
           end

data/lib/graphql/internal_representation/visit.rb

@@ -24,12 +24,9 @@ module GraphQL
       # visiting the node itself and each of its typed children.
       def each_node(node)
         yield(node)
-        if node.typed_children.any?
-          visit_block = Proc.new
-          node.typed_children.each do |obj_type, children|
-            children.each do |name, node|
-              each_node(node, &visit_block)
-            end
+        node.typed_children.each do |obj_type, children|
+          children.each do |name, node|
+            each_node(node) { |n| yield(n) }
           end
         end
       end

data/lib/graphql/introspection/base_object.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class BaseObject < GraphQL::Schema::Object
+      def self.field(*args, **kwargs, &block)
+        kwargs[:introspection] = true
+        super(*args, **kwargs, &block)
+      end
+
+      def self.inherited(child_class)
+        child_class.introspection(true)
+        super
+      end
+    end
+  end
+end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
-GraphQL::Introspection::DirectiveLocationEnum = GraphQL::EnumType.define do
-  name "__DirectiveLocation"
-  description "A Directive can be adjacent to many parts of the GraphQL language, a "\
-              "__DirectiveLocation describes one such possible adjacencies."
+module GraphQL
+  module Introspection
+    class DirectiveLocationEnum < GraphQL::Schema::Enum
+      graphql_name "__DirectiveLocation"
+      description "A Directive can be adjacent to many parts of the GraphQL language, "\
+                  "a __DirectiveLocation describes one such possible adjacencies."
 
-  GraphQL::Directive::LOCATIONS.each do |location|
-    value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      GraphQL::Directive::LOCATIONS.each do |location|
+        value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      end
+      introspection true
+    end
   end
-  introspection true
 end

data/lib/graphql/introspection/directive_type.rb

@@ -1,18 +1,25 @@
 # frozen_string_literal: true
-GraphQL::Introspection::DirectiveType = GraphQL::ObjectType.define do
-  name "__Directive"
-  description "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document."\
-              "\n\n"\
-              "In some cases, you need to provide options to alter GraphQL's execution behavior "\
-              "in ways field arguments will not suffice, such as conditionally including or "\
-              "skipping a field. Directives provide this by describing additional information "\
-              "to the executor."
-  field :name, !types.String
-  field :description, types.String
-  field :locations, !types[!GraphQL::Introspection::DirectiveLocationEnum]
-  field :args, field: GraphQL::Introspection::ArgumentsField
-  field :onOperation, !types.Boolean, deprecation_reason: "Use `locations`.", property: :on_operation?
-  field :onFragment, !types.Boolean, deprecation_reason: "Use `locations`.", property: :on_fragment?
-  field :onField, !types.Boolean, deprecation_reason: "Use `locations`.", property: :on_field?
-  introspection true
+module GraphQL
+  module Introspection
+    class DirectiveType < Introspection::BaseObject
+      graphql_name "__Directive"
+      description "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document."\
+                  "\n\n"\
+                  "In some cases, you need to provide options to alter GraphQL's execution behavior "\
+                  "in ways field arguments will not suffice, such as conditionally including or "\
+                  "skipping a field. Directives provide this by describing additional information "\
+                    "to the executor."
+      field :name, String, null: false
+      field :description, String, null: true
+      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
+      field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
+      field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
+
+      def args
+        @context.warden.arguments(@object)
+      end
+    end
+  end
 end

data/lib/graphql/introspection/dynamic_fields.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class DynamicFields < GraphQL::Schema::Object
+      field :__typename, String, "The name of this type", null: false, extras: [:irep_node]
+      def __typename(irep_node:)
+        irep_node.owner_type.name
+      end
+    end
+  end
+end

data/lib/graphql/introspection/entry_points.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class EntryPoints < GraphQL::Schema::Object
+      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", null: true do
+        argument :name, String, required: true
+      end
+
+      def __schema
+        # Apply wrapping manually since this field isn't wrapped by instrumentation
+        schema = @context.query.schema
+        schema_type = schema.introspection_system.schema_type
+        schema_type.metadata[:type_class].new(schema, @context)
+      end
+
+      def __type(name:)
+        type = @context.warden.get_type(name)
+        if type
+          # Apply wrapping manually since this field isn't wrapped by instrumentation
+          type_type = @context.schema.introspection_system.type_type
+          type_type.metadata[:type_class].new(type, @context)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/introspection/enum_value_type.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
-GraphQL::Introspection::EnumValueType = GraphQL::ObjectType.define do
-  name "__EnumValue"
-  description "One possible value for a given Enum. Enum values are unique values, not a "\
-              "placeholder for a string or numeric value. However an Enum value is returned in "\
-              "a JSON response as a string."
-  field :name, !types.String
-  field :description, types.String
-  field :isDeprecated, !types.Boolean do
-    resolve ->(obj, a, c) { !!obj.deprecation_reason }
+module GraphQL
+  module Introspection
+    class EnumValueType < Introspection::BaseObject
+      graphql_name "__EnumValue"
+      description "One possible value for a given Enum. Enum values are unique values, not a "\
+                  "placeholder for a string or numeric value. However an Enum value is returned in "\
+                  "a JSON response as a string."
+      field :name, String, null: false
+      field :description, String, null: true
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String, null: true
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
+    end
   end
-  field :deprecationReason, types.String, property: :deprecation_reason
-  introspection true
 end