graphql 1.9.17 → 2.0.21

data/lib/graphql/execution/interpreter.rb

@@ -1,97 +1,229 @@
 # frozen_string_literal: true
+require "fiber"
+require "graphql/execution/interpreter/argument_value"
+require "graphql/execution/interpreter/arguments"
+require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
-require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
 require "graphql/execution/interpreter/resolve"
+require "graphql/execution/interpreter/handles_raw_value"
 
 module GraphQL
   module Execution
     class Interpreter
-      def initialize
-      end
+      class << self
+        # Used internally to signal that the query shouldn't be executed
+        # @api private
+        NO_OPERATION = GraphQL::EmptyObjects::EMPTY_HASH
 
-      # Support `Executor` :S
-      def execute(_operation, _root_type, query)
-        runtime = evaluate(query)
-        sync_lazies(query: query)
-        runtime.final_value
-      end
+        # @param schema [GraphQL::Schema]
+        # @param queries [Array<GraphQL::Query, Hash>]
+        # @param context [Hash]
+        # @param max_complexity [Integer, nil]
+        # @return [Array<Hash>] One result per query
+        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          queries = query_options.map do |opts|
+            case opts
+            when Hash
+              GraphQL::Query.new(schema, nil, **opts)
+            when GraphQL::Query
+              opts
+            else
+              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+            end
+          end
 
-      def self.use(schema_defn)
-        schema_defn.target.interpreter = true
-        # Reach through the legacy objects for the actual class defn
-        schema_class = schema_defn.target.class
-        # This is not good, since both of these are holding state now,
-        # we have to update both :(
-        [schema_class, schema_defn].each do |schema_config|
-          schema_config.query_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.mutation_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.subscription_execution_strategy(GraphQL::Execution::Interpreter)
-        end
-      end
+          multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
+            schema = multiplex.schema
+            queries = multiplex.queries
+            query_instrumenters = schema.instrumenters[:query]
+            multiplex_instrumenters = schema.instrumenters[:multiplex]
+            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
 
-      def self.begin_multiplex(multiplex)
-        # Since this is basically the batching context,
-        # share it for a whole multiplex
-        multiplex.context[:interpreter_instance] ||= self.new
-      end
+            # 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
+                schema = multiplex.schema
+                multiplex_analyzers = schema.multiplex_analyzers
+                queries = multiplex.queries
+                if multiplex.max_complexity
+                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+                end
 
-      def self.begin_query(query, multiplex)
-        # The batching context is shared by the multiplex,
-        # so fetch it out and use that instance.
-        interpreter =
-          query.context.namespace(:interpreter)[:interpreter_instance] =
-          multiplex.context[:interpreter_instance]
-        interpreter.evaluate(query)
-        query
-      end
+                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+                begin
+                  # Since this is basically the batching context,
+                  # share it for a whole multiplex
+                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
+                  # Do as much eager evaluation of the query as possible
+                  results = []
+                  queries.each_with_index do |query, idx|
+                    multiplex.dataloader.append_job {
+                      operation = query.selected_operation
+                      result = if operation.nil? || !query.valid? || query.context.errors.any?
+                        NO_OPERATION
+                      else
+                        begin
+                          # Although queries in a multiplex _share_ an Interpreter instance,
+                          # they also have another item of state, which is private to that query
+                          # in particular, assign it here:
+                          runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
-      def self.finish_multiplex(_results, multiplex)
-        interpreter = multiplex.context[:interpreter_instance]
-        interpreter.sync_lazies(multiplex: multiplex)
-      end
+                          query.current_trace.execute_query(query: query) do
+                            runtime.run_eager
+                          end
+                        rescue GraphQL::ExecutionError => err
+                          query.context.errors << err
+                          NO_OPERATION
+                        end
+                      end
+                      results[idx] = result
+                    }
+                  end
 
-      def self.finish_query(query, _multiplex)
-        {
-          "data" => query.context.namespace(:interpreter)[:runtime].final_value
-        }
-      end
+                  multiplex.dataloader.run
+
+                  # Then, work through lazy results in a breadth-first way
+                  multiplex.dataloader.append_job {
+                    tracer = multiplex
+                    query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+                    queries = multiplex ? multiplex.queries : [query]
+                    final_values = queries.map do |query|
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                      # it might not be present if the query has an error
+                      runtime ? runtime.final_result : nil
+                    end
+                    final_values.compact!
+                    tracer.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
+                      Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
+                    end
+                    queries.each do |query|
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                      if runtime
+                        runtime.delete_all_interpreter_context
+                      end
+                    end
+                  }
+                  multiplex.dataloader.run
+
+                  # Then, find all errors and assign the result to the query object
+                  results.each_with_index do |data_result, idx|
+                    query = queries[idx]
+                    # Assign the result so that it can be accessed in instrumentation
+                    query.result_values = if data_result.equal?(NO_OPERATION)
+                      if !query.valid? || query.context.errors.any?
+                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                        { "errors" => query.static_errors.map(&:to_h) }
+                      else
+                        data_result
+                      end
+                    else
+                      result = {
+                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
+                      }
+
+                      if query.context.errors.any?
+                        error_result = query.context.errors.map(&:to_h)
+                        result["errors"] = error_result
+                      end
 
-      # Run the eager part of `query`
-      # @return {Interpreter::Runtime}
-      def evaluate(query)
-        # Although queries in a multiplex _share_ an Interpreter instance,
-        # they also have another item of state, which is private to that query
-        # in particular, assign it here:
-        runtime = Runtime.new(
-          query: query,
-          response: HashResponse.new,
-        )
-        query.context.namespace(:interpreter)[:runtime] = runtime
-
-        query.trace("execute_query", {query: query}) do
-          runtime.run_eager
+                      result
+                    end
+                    if query.context.namespace?(:__query_result_extensions__)
+                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+                    end
+                    # Get the Query::Result, not the Hash
+                    results[idx] = query.result
+                  end
+
+                  results
+                rescue Exception
+                  # TODO rescue at a higher level so it will catch errors in analysis, too
+                  # Assign values here so that the query's `@executed` becomes true
+                  queries.map { |q| q.result_values ||= {} }
+                  raise
+                ensure
+                  queries.map { |query|
+                    runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                    if runtime
+                      runtime.delete_all_interpreter_context
+                    end
+                  }
+                end
+              end
+            end
+          end
         end
 
-        runtime
-      end
+        private
 
-      # Run the lazy part of `query` or `multiplex`.
-      # @return [void]
-      def sync_lazies(query: nil, multiplex: nil)
-        tracer = query || multiplex
-        if query.nil? && multiplex.queries.length == 1
-          query = multiplex.queries[0]
+        # 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
-        queries = multiplex ? multiplex.queries : [query]
-        final_values = queries.map do |query|
-          runtime = query.context.namespace(:interpreter)[:runtime]
-          # it might not be present if the query has an error
-          runtime ? runtime.final_value : nil
+
+        # 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)
+          begin
+            successful = []
+            instrumenters.each do |instrumenter|
+              instrumenter.public_send(before_hook_name, object)
+              successful << instrumenter
+            end
+
+            # 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
+
+          begin
+            yield # Call the user code
+          ensure
+            ex = call_after_hooks(successful, object, after_hook_name, nil)
+            raise ex if ex
+          end
         end
-        final_values.compact!
-        tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          Interpreter::Resolve.resolve_all(final_values)
+
+        def call_after_hooks(instrumenters, object, after_hook_name, ex)
+          instrumenters.reverse_each do |instrumenter|
+            begin
+              instrumenter.public_send(after_hook_name, object)
+            rescue => e
+              ex = e
+            end
+          end
+          ex
+        end
+      end
+
+      class ListResultFailedError < GraphQL::Error
+        def initialize(value:, path:, field:)
+          message = "Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
+
+          message << "Expected `#{value.inspect}` (#{value.class}) to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+
+          if field.connection?
+            message << "\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."
+          end
+          super(message)
         end
       end
     end

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

@@ -36,6 +36,10 @@ module GraphQL
           @storage.compute_if_absent(value.class) { find_superclass_method(value.class) }
         end
 
+        def each
+          @storage.each_pair { |k, v| yield(k, v) }
+        end
+
         protected
 
         attr_reader :storage

data/lib/graphql/execution/lazy.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "graphql/execution/lazy/lazy_method_map"
-require "graphql/execution/lazy/resolve"
 
 module GraphQL
   module Execution
@@ -13,23 +12,14 @@ module GraphQL
     # - It has no error-catching functionality
     # @api private
     class Lazy
-      # Traverse `val`, lazily resolving any values along the way
-      # @param val [Object] A data structure containing mixed plain values and `Lazy` instances
-      # @return void
-      def self.resolve(val)
-        Resolve.resolve(val)
-      end
-
-      attr_reader :path, :field
+      attr_reader :field
 
       # Create a {Lazy} which will get its inner value by calling the block
-      # @param path [Array<String, Integer>]
       # @param field [GraphQL::Schema::Field]
       # @param get_value_func [Proc] a block to get the inner value (later)
-      def initialize(path: nil, field: nil, &get_value_func)
+      def initialize(field: nil, &get_value_func)
         @get_value_func = get_value_func
         @resolved = false
-        @path = path
         @field = field
       end
 
@@ -37,18 +27,18 @@ module GraphQL
       def value
         if !@resolved
           @resolved = true
-          @value = begin
-            v = @get_value_func.call
-            if v.is_a?(Lazy)
-              v = v.value
-            end
-            v
-          rescue GraphQL::ExecutionError => err
-            err
+          v = @get_value_func.call
+          if v.is_a?(Lazy)
+            v = v.value
           end
+          @value = v
         end
 
-        if @value.is_a?(StandardError)
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
           raise @value
         else
           @value

data/lib/graphql/execution/lookahead.rb

@@ -51,7 +51,17 @@ module GraphQL
 
       # @return [Hash<Symbol, Object>]
       def arguments
-        @arguments ||= @field && ArgumentHelpers.arguments(@query, nil, @field, ast_nodes.first)
+        if defined?(@arguments)
+          @arguments
+        else
+          @arguments = if @field
+            @query.schema.after_lazy(@query.arguments_for(@ast_nodes.first, @field)) do |args|
+              args.is_a?(Execution::Interpreter::Arguments) ? args.keyword_arguments : args
+            end
+          else
+            nil
+          end
+        end
       end
 
       # True if this node has a selection on `field_name`.
@@ -66,8 +76,8 @@ module GraphQL
       # @param field_name [String, Symbol]
       # @param arguments [Hash] Arguments which must match in the selection
       # @return [Boolean]
-      def selects?(field_name, arguments: nil)
-        selection(field_name, arguments: arguments).selected?
+      def selects?(field_name, selected_type: @selected_type, arguments: nil)
+        selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
       # @return [Boolean] True if this lookahead represents a field that was requested
@@ -77,16 +87,39 @@ module GraphQL
 
       # Like {#selects?}, but can be used for chaining.
       # It returns a null object (check with {#selected?})
+      # @param field_name [String, Symbol]
       # @return [GraphQL::Execution::Lookahead]
       def selection(field_name, selected_type: @selected_type, arguments: nil)
-        next_field_name = normalize_name(field_name)
+        next_field_defn = case field_name
+        when String
+          @query.get_field(selected_type, field_name)
+        when Symbol
+          # Try to avoid the `.to_s` below, if possible
+          all_fields = if selected_type.kind.fields?
+            @query.warden.fields(selected_type)
+          else
+            # Handle unions by checking possible
+            @query.warden
+              .possible_types(selected_type)
+              .map { |t| @query.warden.fields(t) }
+              .flatten
+          end
+
+          if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
+            match_by_orig_name
+          else
+            # Symbol#name is only present on 3.0+
+            sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
+            guessed_name = Schema::Member::BuildType.camelize(sym_s)
+            @query.get_field(selected_type, guessed_name)
+          end
+        end
 
-        next_field_defn = FieldHelpers.get_field(@query.schema, selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
             ast_node.selections.each do |selection|
-              find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+              find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
             end
           end
 
@@ -127,7 +160,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = FieldHelpers.get_field(@query.schema, type, ast_nodes.first.name)
+            field_defn = @query.get_field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -186,25 +219,22 @@ module GraphQL
 
       private
 
-      # If it's a symbol, stringify and camelize it
-      def normalize_name(name)
-        if name.is_a?(Symbol)
-          Schema::Member::BuildType.camelize(name.to_s)
-        else
-          name
-        end
-      end
-
-      def normalize_keyword(keyword)
-        if keyword.is_a?(String)
-          Schema::Member::BuildType.underscore(keyword).to_sym
-        else
-          keyword
+      def skipped_by_directive?(ast_selection)
+        ast_selection.directives.each do |directive|
+          dir_defn = @query.schema.directives.fetch(directive.name)
+          directive_class = dir_defn
+          if directive_class
+            dir_args = @query.arguments_for(directive, dir_defn)
+            return true unless directive_class.static_include?(dir_args, @query.context)
+          end
         end
+        false
       end
 
       def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments)
         ast_selections.each do |ast_selection|
+          next if skipped_by_directive?(ast_selection)
+
           case ast_selection
           when GraphQL::Language::Nodes::Field
             response_key = ast_selection.alias || ast_selection.name
@@ -213,7 +243,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = FieldHelpers.get_field(@query.schema, selected_type, ast_selection.name)
+              field_defn = @query.get_field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -223,14 +253,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.schema.types[t.name].metadata[:type_class]
+              on_type = @query.get_type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            on_type = @query.schema.types[frag_defn.type.name].metadata[:type_class]
+            on_type = @query.get_type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else
@@ -241,10 +271,11 @@ module GraphQL
 
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
-      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:)
+      def find_selected_nodes(node, field_defn, arguments:, matches:)
+        return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
-          if node.name == field_name
+          if node.name == field_defn.graphql_name
             if arguments.nil? || arguments.empty?
               # No constraint applied
               matches << node
@@ -253,128 +284,26 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          node.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         when GraphQL::Language::Nodes::FragmentSpread
           frag_defn = @query.fragments[node.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})")
-          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          frag_defn.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
       end
 
       def arguments_match?(arguments, field_defn, field_node)
-        query_kwargs = ArgumentHelpers.arguments(@query, nil, field_defn, field_node)
+        query_kwargs = @query.arguments_for(field_node, field_defn)
         arguments.all? do |arg_name, arg_value|
-          arg_name = normalize_keyword(arg_name)
-          # Make sure the constraint is present with a matching value
-          query_kwargs.key?(arg_name) && query_kwargs[arg_name] == arg_value
-        end
-      end
-
-      # TODO Dedup with interpreter
-      module ArgumentHelpers
-        module_function
-
-        def arguments(query, graphql_object, arg_owner, ast_node)
-          kwarg_arguments = {}
-          arg_defns = arg_owner.arguments
-          ast_node.arguments.each do |arg|
-            arg_defn = arg_defns[arg.name] || raise("Invariant: missing argument definition for #{arg.name.inspect} in #{arg_defns.keys} from #{arg_owner}")
-            # Need to distinguish between client-provided `nil`
-            # and nothing-at-all
-            is_present, value = arg_to_value(query, graphql_object, arg_defn.type, arg.value)
-            if is_present
-              # This doesn't apply to directives, which are legacy
-              # Can remove this when Skip and Include use classes or something.
-              if graphql_object
-                value = arg_defn.prepare_value(graphql_object, value)
-              end
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          arg_defns.each do |name, arg_defn|
-            if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              kwarg_arguments[arg_defn.keyword] = arg_defn.default_value
-            end
-          end
-          kwarg_arguments
-        end
-
-        # Get a Ruby-ready value from a client query.
-        # @param graphql_object [Object] The owner of the field whose argument this is
-        # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
-        # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
-        # @return [Array(is_present, value)]
-        def arg_to_value(query, graphql_object, arg_type, ast_value)
-          if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-            # If it's not here, it will get added later
-            if query.variables.key?(ast_value.name)
-              return true, query.variables[ast_value.name]
-            else
-              return false, nil
-            end
-          elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-            return true, nil
-          elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(query, graphql_object, arg_type.of_type, ast_value)
-          elsif arg_type.is_a?(GraphQL::Schema::List)
-            # Treat a single value like a list
-            arg_value = Array(ast_value)
-            list = []
-            arg_value.map do |inner_v|
-              _present, value = arg_to_value(query, graphql_object, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
-          elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            # For these, `prepare` is applied during `#initialize`.
-            # Pass `nil` so it will be skipped in `#arguments`.
-            # What a mess.
-            args = arguments(query, nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
-            return true, arg_type.new(ruby_kwargs: args, context: query.context, defaults_used: nil)
-          else
-            flat_value = flatten_ast_value(query, ast_value)
-            return true, arg_type.coerce_input(flat_value, query.context)
-          end
-        end
-
-        def flatten_ast_value(query, v)
-          case v
-          when GraphQL::Language::Nodes::Enum
-            v.name
-          when GraphQL::Language::Nodes::InputObject
-            h = {}
-            v.arguments.each do |arg|
-              h[arg.name] = flatten_ast_value(query, arg.value)
-            end
-            h
-          when Array
-            v.map { |v2| flatten_ast_value(query, v2) }
-          when GraphQL::Language::Nodes::VariableIdentifier
-            flatten_ast_value(query.variables[v.name])
-          else
-            v
-          end
-        end
-      end
-
-      # TODO dedup with interpreter
-      module FieldHelpers
-        module_function
-
-        def get_field(schema, owner_type, field_name)
-          field_defn = owner_type.get_field(field_name)
-          field_defn ||= if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
-            entry_point_field.metadata[:type_class]
-          elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field.metadata[:type_class]
+          arg_name_sym = if arg_name.is_a?(String)
+            Schema::Member::BuildType.underscore(arg_name).to_sym
           else
-            nil
+            arg_name
           end
 
-          field_defn
+          # Make sure the constraint is present with a matching value
+          query_kwargs.key?(arg_name_sym) && query_kwargs[arg_name_sym] == arg_value
         end
       end
     end