graphql 1.6.8 → 1.7.0

data/lib/graphql/enum_type.rb

@@ -141,13 +141,7 @@ module GraphQL
 
       def name=(new_name)
         # Validate that the name is correct
-        unless new_name =~ /^[_a-zA-Z][_a-zA-Z0-9]*$/
-          raise(
-            GraphQL::EnumType::InvalidEnumNameError,
-            "Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but '#{new_name}' does not"
-          )
-        end
-
+        GraphQL::NameValidator.validate!(new_name)
         @name = new_name
       end
     end
@@ -155,9 +149,6 @@ module GraphQL
     class UnresolvedValueError < GraphQL::Error
     end
 
-    class InvalidEnumNameError < GraphQL::Error
-    end
-
     private
 
     # Get the underlying value for this enum value

data/lib/graphql/execution.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
-require "graphql/execution/field_result"
+require "graphql/execution/flatten"
 require "graphql/execution/lazy"
 require "graphql/execution/multiplex"
-require "graphql/execution/selection_result"
 require "graphql/execution/typecast"

data/lib/graphql/execution/execute.rb

@@ -13,104 +13,126 @@ module GraphQL
       SKIP = Skip.new
 
       # @api private
-      PROPAGATE_NULL = Object.new
+      class PropagateNull
+      end
+      # @api private
+      PROPAGATE_NULL = PropagateNull.new
 
       def execute(ast_operation, root_type, query)
-        result = resolve_selection(
-          query.root_value,
-          root_type,
-          query.irep_selection,
-          query.context,
-          mutation: query.mutation?
-        )
-
-        GraphQL::Execution::Lazy.resolve(result)
-
-        result.to_h
+        result = resolve_root_selection(query)
+        lazy_resolve_root_selection(result, {query: query})
+        GraphQL::Execution::Flatten.call(query.context)
       end
 
       # @api private
       module ExecutionFunctions
         module_function
 
-        def resolve_selection(object, current_type, selection, query_ctx, mutation: false )
-          selection_result = SelectionResult.new
-
-          selection.typed_children[current_type].each do |name, subselection|
-            field_result = resolve_field(
-              selection_result,
-              subselection,
-              current_type,
-              subselection.definition,
-              object,
-              query_ctx
+        def resolve_root_selection(query)
+          GraphQL::Tracing.trace("execute_query", query: query) do
+            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?
             )
+          end
+        end
+
+        def lazy_resolve_root_selection(result, query: nil, queries: nil)
+          if query.nil? && queries.length == 1
+            query = queries[0]
+          end
+
+          GraphQL::Tracing.trace("execute_query_lazy", {queries: queries, query: query}) do
+            GraphQL::Execution::Lazy.resolve(result)
+          end
+        end
+
+        def resolve_selection(object, current_type, current_ctx, mutation: false )
+          # Assign this _before_ resolving the children
+          # so that when a child propagates null, the selection result is
+          # ready for it.
+          current_ctx.value = {}
+
+          selections_on_type = current_ctx.irep_node.typed_children[current_type]
+
+          selections_on_type.each do |name, child_irep_node|
+            field_ctx = current_ctx.spawn_child(
+              key: name,
+              object: object,
+              irep_node: child_irep_node,
+            )
+
+            field_result = GraphQL::Tracing.trace("execute_field", { context: field_ctx }) do
+              resolve_field(
+                object,
+                field_ctx
+              )
+            end
 
             if field_result.is_a?(Skip)
               next
             end
 
             if mutation
-              GraphQL::Execution::Lazy.resolve(field_result)
+              GraphQL::Execution::Lazy.resolve(field_ctx)
             end
 
-            selection_result.set(name, field_result)
 
             # If the last subselection caused a null to propagate to _this_ selection,
             # then we may as well quit executing fields because they
             # won't be in the response
-            if selection_result.invalid_null?
+            if current_ctx.invalid_null?
               break
+            else
+              current_ctx.value[name] = field_ctx
             end
           end
 
-          selection_result
+          current_ctx.value
         end
 
-        def resolve_field(owner, selection, parent_type, field, object, query_ctx)
-          query = query_ctx.query
-          field_ctx = query_ctx.spawn(
-            parent_type: parent_type,
-            field: field,
-            key: selection.name,
-            selection: selection,
-          )
+        def resolve_field(object, field_ctx)
+          query = field_ctx.query
+          irep_node = field_ctx.irep_node
+          parent_type = irep_node.owner_type
+          field = field_ctx.field
 
           raw_value = begin
-            arguments = query.arguments_for(selection, field)
-            query_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+            arguments = query.arguments_for(irep_node, field)
+            field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
           rescue GraphQL::ExecutionError => err
             err
           end
 
-          result = if query.schema.lazy?(raw_value)
-            field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
-              continue_resolve_field(owner, selection, parent_type, field, inner_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
+          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
-            raw_value.then { |inner_value|
-              continue_resolve_field(owner, selection, parent_type, field, inner_value, field_ctx)
+            field_ctx.value = raw_value.then { |inner_value|
+              field_ctx.value = continue_resolve_field(inner_value, field_ctx)
             }
           else
-            continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
-          end
-
-          case result
-          when PROPAGATE_NULL, GraphQL::Execution::Lazy, SelectionResult
-            FieldResult.new(
-              owner: owner,
-              type: field.type,
-              value: result,
-            )
-          else
-            result
+            field_ctx.value = continue_resolve_field(raw_value, field_ctx)
           end
         end
 
-        def continue_resolve_field(owner, selection, parent_type, field, raw_value, field_ctx)
-          if owner.invalid_null?
-            return
+        def continue_resolve_field(raw_value, field_ctx)
+          if field_ctx.parent.invalid_null?
+            return nil
           end
           query = field_ctx.query
 
@@ -131,19 +153,18 @@ module GraphQL
           end
 
           resolve_value(
-            owner,
-            parent_type,
-            field,
-            field.type,
             raw_value,
-            selection,
+            field_ctx.type,
             field_ctx,
           )
         end
 
-        def resolve_value(owner, parent_type, field_defn, field_type, value, selection, field_ctx)
+        def resolve_value(value, field_type, field_ctx)
+          field_defn = field_ctx.field
+
           if value.nil?
             if field_type.kind.non_null?
+              parent_type = field_ctx.irep_node.owner_type
               type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
               field_ctx.schema.type_error(type_error, field_ctx)
               PROPAGATE_NULL
@@ -157,55 +178,46 @@ module GraphQL
               nil
             end
           elsif value.is_a?(Skip)
-            value
+            field_ctx.value = value
           else
             case field_type.kind
-            when GraphQL::TypeKinds::SCALAR
-              field_type.coerce_result(value, field_ctx)
-            when GraphQL::TypeKinds::ENUM
+            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
               field_type.coerce_result(value, field_ctx)
             when GraphQL::TypeKinds::LIST
               inner_type = field_type.of_type
               i = 0
               result = []
+              field_ctx.value = result
+
               value.each do |inner_value|
-                inner_ctx = field_ctx.spawn(
+                inner_ctx = field_ctx.spawn_child(
                   key: i,
-                  selection: selection,
-                  parent_type: parent_type,
-                  field: field_defn,
+                  object: inner_value,
+                  irep_node: field_ctx.irep_node,
                 )
 
                 inner_result = resolve_value(
-                  owner,
-                  parent_type,
-                  field_defn,
-                  inner_type,
                   inner_value,
-                  selection,
+                  inner_type,
                   inner_ctx,
                 )
 
-                result << GraphQL::Execution::FieldResult.new(type: inner_type, owner: owner, value: inner_result)
+                inner_ctx.value = inner_result
+                result << inner_ctx
                 i += 1
               end
               result
             when GraphQL::TypeKinds::NON_NULL
-              wrapped_type = field_type.of_type
+              inner_type = field_type.of_type
               resolve_value(
-                owner,
-                parent_type,
-                field_defn,
-                wrapped_type,
                 value,
-                selection,
+                inner_type,
                 field_ctx,
               )
             when GraphQL::TypeKinds::OBJECT
               resolve_selection(
                 value,
                 field_type,
-                selection,
                 field_ctx
               )
             when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
@@ -214,17 +226,14 @@ module GraphQL
               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(
-                  owner,
-                  parent_type,
-                  field_defn,
-                  resolved_type,
                   value,
-                  selection,
+                  resolved_type,
                   field_ctx,
                 )
               end

data/lib/graphql/execution/flatten.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Starting from a root context,
+    # create a hash out of the context tree.
+    # @api private
+    module Flatten
+      def self.call(ctx)
+        flatten(ctx)
+      end
+
+      class << self
+        private
+
+        def flatten(obj)
+          case obj
+          when Hash
+            flattened = {}
+            obj.each do |key, val|
+              flattened[key] = flatten(val)
+            end
+            flattened
+          when Array
+            obj.map { |v| flatten(v) }
+          when Query::Context::SharedMethods
+            if obj.invalid_null?
+              nil
+            elsif obj.skipped? && obj.value.empty?
+              nil
+            else
+              flatten(obj.value)
+            end
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -36,10 +36,10 @@ module GraphQL
             Lazy::NullResult
           else
             Lazy.new {
-              acc.each_with_index { |field_result, idx|
-                inner_v = field_result.value.value
-                field_result.value = inner_v
-                acc[idx] = inner_v
+              acc.each_with_index { |ctx, idx|
+                acc[idx] = GraphQL::Tracing.trace("execute_field_lazy", { context: ctx }) do
+                  ctx.value.value
+                end
               }
               resolve_in_place(acc)
             }
@@ -52,7 +52,7 @@ module GraphQL
         # @return [void]
         def self.each_lazy(acc, value)
           case value
-          when SelectionResult
+          when Hash
             value.each do |key, field_result|
               acc = each_lazy(acc, field_result)
             end
@@ -60,12 +60,12 @@ module GraphQL
             value.each do |field_result|
               acc = each_lazy(acc, field_result)
             end
-          when FieldResult
+          when Query::Context::SharedMethods
             field_value = value.value
             case field_value
             when Lazy
               acc = acc << value
-            when SelectionResult
+            when Enumerable # shortcut for Hash & Array
               acc = each_lazy(acc, field_value)
             end
           end

data/lib/graphql/execution/multiplex.rb

@@ -46,19 +46,21 @@ module GraphQL
         # @param max_complexity [Integer, nil]
         # @return [Array<Hash>] One result per query
         def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
-
-          if has_custom_strategy?(schema)
-            if queries.length != 1
-              raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
+          multiplex = self.new(schema: schema, queries: queries, context: context)
+          GraphQL::Tracing.trace("execute_multiplex", { multiplex: multiplex }) do
+            if has_custom_strategy?(schema)
+              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
+                  [run_one_legacy(schema, queries.first)]
+                end
+              end
             else
-              with_instrumentation(schema, queries, context: context, max_complexity: max_complexity) do
-                [run_one_legacy(schema, queries.first)]
+              with_instrumentation(multiplex, max_complexity: max_complexity) do
+                run_as_multiplex(queries)
               end
             end
-          else
-            with_instrumentation(schema, queries, context: context, max_complexity: max_complexity) do
-              run_as_multiplex(queries)
-            end
           end
         end
 
@@ -71,12 +73,14 @@ module GraphQL
           end
 
           # Then, work through lazy results in a breadth-first way
-          GraphQL::Execution::Lazy.resolve(results)
+          GraphQL::Execution::Execute::ExecutionFunctions.lazy_resolve_root_selection(results, { queries: queries })
 
           # Then, find all errors and assign the result to the query object
           results.each_with_index.map do |data_result, idx|
             query = queries[idx]
             finish_query(data_result, query)
+            # Get the Query::Result, not the Hash
+            query.result
           end
         end
 
@@ -88,18 +92,10 @@ module GraphQL
             NO_OPERATION
           else
             begin
-              op_type = operation.operation_type
-              root_type = query.root_type_for_operation(op_type)
-              GraphQL::Execution::Execute::ExecutionFunctions.resolve_selection(
-                query.root_value,
-                root_type,
-                query.irep_selection,
-                query.context,
-                mutation: query.mutation?
-              )
+              GraphQL::Execution::Execute::ExecutionFunctions.resolve_root_selection(query)
             rescue GraphQL::ExecutionError => err
               query.context.errors << err
-              {}
+              NO_OPERATION
             end
           end
         end
@@ -109,17 +105,20 @@ module GraphQL
         # @return [Hash] final result of this query, including all values and errors
         def finish_query(data_result, query)
           # Assign the result so that it can be accessed in instrumentation
-          query.result = if data_result.equal?(NO_OPERATION)
+          query.result_values = if data_result.equal?(NO_OPERATION)
             if !query.valid?
               { "errors" => query.static_errors.map(&:to_h) }
             else
-              {}
+              data_result
             end
           else
-            result = { "data" => data_result.to_h }
-            error_result = query.context.errors.map(&:to_h)
+            # Use `context.value` which was assigned during execution
+            result = {
+              "data" => Execution::Flatten.call(query.context)
+            }
 
-            if error_result.any?
+            if query.context.errors.any?
+              error_result = query.context.errors.map(&:to_h)
               result["errors"] = error_result
             end
 
@@ -129,7 +128,7 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
-          query.result = if !query.valid?
+          query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?
               { "errors" => all_errors.map(&:to_h) }
@@ -150,10 +149,11 @@ module GraphQL
         # Apply multiplex & query instrumentation to `queries`.
         #
         # It yields when the queries should be executed, then runs teardown.
-        def with_instrumentation(schema, queries, context:, max_complexity:)
+        def with_instrumentation(multiplex, max_complexity:)
+          schema = multiplex.schema
+          queries = multiplex.queries
           query_instrumenters = schema.instrumenters[:query]
           multiplex_instrumenters = schema.instrumenters[:multiplex]
-          multiplex = self.new(schema: schema, queries: queries, context: context)
 
           # First, run multiplex instrumentation, then query instrumentation for each query
           multiplex_instrumenters.each { |i| i.before_multiplex(multiplex) }