feat(Schema) instrumenters can wrap queries

Author: rmosolgo

lib/graphql/query.rb

@@ -91,16 +91,9 @@ def initialize(schema, query_string = nil, document: nil, context: nil, variable
     # Get the result for this query, executing it once
     def result
       @result ||= begin
-        if !valid?
-          all_errors = validation_errors + analysis_errors
-          if all_errors.any?
-            { "errors" => all_errors.map(&:to_h) }
-          else
-            nil
-          end
-        else
-          Executor.new(self).result
-        end
+        instrumenters = @schema.instrumenters[:query]
+        execution_call = ExecutionCall.new(self, instrumenters)
+        execution_call.call
       end
     end
 
@@ -209,5 +202,37 @@ def find_operation(operations, operation_name)
         operations[operation_name]
       end
     end
+
+    class ExecutionCall
+      def initialize(query, instrumenters)
+        @query = query
+        @instrumenters = instrumenters
+      end
+
+      # Check if the query is valid, and if it is,
+      # execute it, calling instrumenters along the way
+      # @return [Hash] The GraphQL response
+      def call
+        @instrumenters.each { |i| i.before_query(@query) }
+        result = get_result
+        @instrumenters.each { |i| i.after_query(@query) }
+        result
+      end
+
+      private
+
+      def get_result
+        if !@query.valid?
+          all_errors = @query.validation_errors + @query.analysis_errors
+          if all_errors.any?
+            { "errors" => all_errors.map(&:to_h) }
+          else
+            nil
+          end
+        else
+          Executor.new(@query).result
+        end
+      end
+    end
   end
 end

lib/graphql/query/variables.rb

@@ -2,6 +2,8 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
+      extend Forwardable
+
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors
 
@@ -20,6 +22,8 @@ def [](key)
         @storage.fetch(key)
       end
 
+      def_delegators :@storage, :length
+
       private
 
       # Find the right value for this variable:

lib/graphql/schema.rb

@@ -110,7 +110,9 @@ def remove_handler(*args, &block)
 
     def define(**kwargs, &block)
       super
-      types
+      all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
+      @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
+
       @instrumented_field_map = InstrumentedFieldMap.new(self)
       field_instrumenters = @instrumenters[:field]
       types.each do |type_name, type|
@@ -134,13 +136,7 @@ def define(**kwargs, &block)
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
-    def types
-      @types ||= begin
-        ensure_defined
-        all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
-        GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
-      end
-    end
+    attr_reader :types
 
     # Execute a query on itself.
     # See {Query#initialize} for arguments.

spec/graphql/schema_spec.rb

@@ -190,18 +190,39 @@ def initialize(multiplier)
       end
 
       def instrument(type_defn, field_defn)
-        prev_proc = field_defn.resolve_proc
-        new_resolve_proc = ->(obj, args, ctx) {
-          inner_value = prev_proc.call(obj, args, ctx)
-          inner_value * @multiplier
-        }
-
-        field_defn.redefine do
-          resolve(new_resolve_proc)
+        if type_defn.name == "Query" && field_defn.name == "int"
+          prev_proc = field_defn.resolve_proc
+          new_resolve_proc = ->(obj, args, ctx) {
+            inner_value = prev_proc.call(obj, args, ctx)
+            inner_value * @multiplier
+          }
+
+          field_defn.redefine do
+            resolve(new_resolve_proc)
+          end
+        else
+          field_defn
         end
       end
     end
 
+    class VariableCountInstrumenter
+      attr_reader :counts
+      def initialize
+        @counts = []
+      end
+
+      def before_query(query)
+        @counts << query.variables.length
+      end
+
+      def after_query(query)
+      end
+    end
+
+    let(:variable_counter) {
+      VariableCountInstrumenter.new
+    }
     let(:query_type) {
       GraphQL::ObjectType.define do
         name "Query"
@@ -217,12 +238,19 @@ def instrument(type_defn, field_defn)
       GraphQL::Schema.define do
         query(spec.query_type)
         instrument(:field, MultiplyInstrumenter.new(3))
+        instrument(:query, spec.variable_counter)
       end
     }
 
     it "can modify field definitions" do
       res = schema.execute(" { int(value: 2) } ")
       assert_equal 6, res["data"]["int"]
     end
+
+    it "can wrap query execution" do
+      schema.execute("query getInt($val: Int = 5){ int(value: $val) } ")
+      schema.execute("query getInt($val: Int = 5, $val2: Int = 3){ int(value: $val) int2: int(value: $val2) } ")
+      assert_equal [1, 2], variable_counter.counts
+    end
   end
 end