graphql_cody 1.13.0

data/lib/graphql/execution/interpreter.rb

@@ -0,0 +1,122 @@
+# 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/runtime"
+require "graphql/execution/interpreter/resolve"
+require "graphql/execution/interpreter/handles_raw_value"
+
+module GraphQL
+  module Execution
+    class Interpreter
+      def initialize
+      end
+
+      # Support `Executor` :S
+      def execute(_operation, _root_type, query)
+        runtime = evaluate(query)
+        sync_lazies(query: query)
+        runtime.final_result
+      end
+
+      def self.use(schema_class)
+        if schema_class.interpreter?
+          definition_line = caller(2, 1).first
+          GraphQL::Deprecation.warn("GraphQL::Execution::Interpreter is now the default; remove `use GraphQL::Execution::Interpreter` from the schema definition (#{definition_line})")
+        else
+          schema_class.query_execution_strategy(self)
+          schema_class.mutation_execution_strategy(self)
+          schema_class.subscription_execution_strategy(self)
+          schema_class.add_subscription_extension_if_necessary
+        end
+      end
+
+      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
+
+      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
+
+      def self.finish_multiplex(_results, multiplex)
+        interpreter = multiplex.context[:interpreter_instance]
+        interpreter.sync_lazies(multiplex: multiplex)
+      end
+
+      def self.finish_query(query, _multiplex)
+        {
+          "data" => query.context.namespace(:interpreter)[:runtime].final_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)
+        query.context.namespace(:interpreter)[:runtime] = runtime
+
+        query.trace("execute_query", {query: query}) do
+          runtime.run_eager
+        end
+
+        runtime
+      end
+
+      # 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]
+        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_result : nil
+        end
+        final_values.compact!
+        tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
+          Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+        end
+        queries.each do |query|
+          runtime = query.context.namespace(:interpreter)[:runtime]
+          if runtime
+            runtime.delete_interpreter_context(:current_path)
+            runtime.delete_interpreter_context(:current_field)
+            runtime.delete_interpreter_context(:current_object)
+            runtime.delete_interpreter_context(:current_arguments)
+          end
+        end
+        nil
+      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
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'thread'
+begin
+  require 'concurrent'
+rescue LoadError
+  # no problem, we'll fallback to our own map
+end
+
+module GraphQL
+  module Execution
+    class Lazy
+      # {GraphQL::Schema} uses this to match returned values to lazy resolution methods.
+      # Methods may be registered for classes, they apply to its subclasses also.
+      # The result of this lookup is cached for future resolutions.
+      # Instances of this class are thread-safe.
+      # @api private
+      # @see {Schema#lazy?} looks up values from this map
+      class LazyMethodMap
+        def initialize(use_concurrent: defined?(Concurrent::Map))
+          @storage = use_concurrent ? Concurrent::Map.new : ConcurrentishMap.new
+        end
+
+        def initialize_copy(other)
+          @storage = other.storage.dup
+        end
+
+        # @param lazy_class [Class] A class which represents a lazy value (subclasses may also be used)
+        # @param lazy_value_method [Symbol] The method to call on this class to get its value
+        def set(lazy_class, lazy_value_method)
+          @storage[lazy_class] = lazy_value_method
+        end
+
+        # @param value [Object] an object which may have a `lazy_value_method` registered for its class or superclasses
+        # @return [Symbol, nil] The `lazy_value_method` for this object, or nil
+        def get(value)
+          @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
+
+        private
+
+        def find_superclass_method(value_class)
+          @storage.each_pair { |lazy_class, lazy_value_method|
+            return lazy_value_method if value_class < lazy_class
+          }
+          nil
+        end
+
+        # Mock the Concurrent::Map API
+        class ConcurrentishMap
+          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
+
+          def initialize
+            @semaphore = Mutex.new
+            # Access to this hash must always be managed by the mutex
+            # since it may be modified at runtime
+            @storage = {}
+          end
+
+          def []=(key, value)
+            @semaphore.synchronize {
+              @storage[key] = value
+            }
+          end
+
+          def compute_if_absent(key)
+            @semaphore.synchronize {
+              @storage.fetch(key) { @storage[key] = yield }
+            }
+          end
+
+          def initialize_copy(other)
+            @semaphore = Mutex.new
+            @storage = other.copy_storage
+          end
+
+          protected
+
+          def copy_storage
+            @semaphore.synchronize {
+              @storage.dup
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    class Lazy
+      # Helpers for dealing with data structures containing {Lazy} instances
+      # @api private
+      module Resolve
+        # Mutate `value`, replacing {Lazy} instances in place with their resolved values
+        # @return [void]
+
+        # This object can be passed like an array, but it doesn't allocate an
+        # array until it's used.
+        #
+        # There's one crucial difference: you have to _capture_ the result
+        # of `#<<`. (This _works_ with arrays but isn't required, since it has a side-effect.)
+        # @api private
+        module NullAccumulator
+          def self.<<(item)
+            [item]
+          end
+
+          def self.empty?
+            true
+          end
+        end
+
+        def self.resolve(value)
+          lazies = resolve_in_place(value)
+          deep_sync(lazies)
+        end
+
+        def self.resolve_in_place(value)
+          acc = each_lazy(NullAccumulator, value)
+
+          if acc.empty?
+            Lazy::NullResult
+          else
+            Lazy.new {
+              acc.each_with_index { |ctx, idx|
+                acc[idx] = ctx.value.value
+              }
+              resolve_in_place(acc)
+            }
+          end
+        end
+
+        # If `value` is a collection,
+        # add any {Lazy} instances in the collection
+        # to `acc`
+        # @return [void]
+        def self.each_lazy(acc, value)
+          case value
+          when Hash
+            value.each do |key, field_result|
+              acc = each_lazy(acc, field_result)
+            end
+          when Array
+            value.each do |field_result|
+              acc = each_lazy(acc, field_result)
+            end
+          when Query::Context::SharedMethods
+            field_value = value.value
+            case field_value
+            when Lazy
+              acc = acc << value
+            when Enumerable # shortcut for Hash & Array
+              acc = each_lazy(acc, field_value)
+            end
+          end
+
+          acc
+        end
+
+        # Traverse `val`, triggering resolution for each {Lazy}.
+        # These {Lazy}s are expected to mutate their owner data structures
+        # during resolution! (They're created with the `.then` calls in `resolve_in_place`).
+        # @return [void]
+        def self.deep_sync(val)
+          case val
+          when Lazy
+            deep_sync(val.value)
+          when Array
+            val.each { |v| deep_sync(v.value) }
+          when Hash
+            val.each { |k, v| deep_sync(v.value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/lazy.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require "graphql/execution/lazy/lazy_method_map"
+require "graphql/execution/lazy/resolve"
+
+module GraphQL
+  module Execution
+    # This wraps a value which is available, but not yet calculated, like a promise or future.
+    #
+    # Calling `#value` will trigger calculation & return the "lazy" value.
+    #
+    # This is an itty-bitty promise-like object, with key differences:
+    # - It has only two states, not-resolved and resolved
+    # - 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
+
+      # 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)
+        @get_value_func = get_value_func
+        @resolved = false
+        @path = path
+        @field = field
+      end
+
+      # @return [Object] The wrapped value, calling the lazy block if necessary
+      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
+          end
+        end
+
+        # `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::Execute::SKIP
+          raise @value
+        else
+          @value
+        end
+      end
+
+      # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
+      def then
+        self.class.new {
+          yield(value)
+        }
+      end
+
+      # @param lazies [Array<Object>] Maybe-lazy objects
+      # @return [Lazy] A lazy which will sync all of `lazies`
+      def self.all(lazies)
+        self.new {
+          lazies.map { |l| l.is_a?(Lazy) ? l.value : l }
+        }
+      end
+
+      # This can be used for fields which _had no_ lazy results
+      # @api private
+      NullResult = Lazy.new(){}
+      NullResult.value
+    end
+  end
+end

data/lib/graphql/execution/lookahead.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Lookahead creates a uniform interface to inspect the forthcoming selections.
+    #
+    # It assumes that the AST it's working with is valid. (So, it's safe to use
+    # during execution, but if you're using it directly, be sure to validate first.)
+    #
+    # A field may get access to its lookahead by adding `extras: [:lookahead]`
+    # to its configuration.
+    #
+    # @example looking ahead in a field
+    #   field :articles, [Types::Article], null: false,
+    #     extras: [:lookahead]
+    #
+    #   # For example, imagine a faster database call
+    #   # may be issued when only some fields are requested.
+    #   #
+    #   # Imagine that _full_ fetch must be made to satisfy `fullContent`,
+    #   # we can look ahead to see if we need that field. If we do,
+    #   # we make the expensive database call instead of the cheap one.
+    #   def articles(lookahead:)
+    #     if lookahead.selects?(:full_content)
+    #       fetch_full_articles(object)
+    #     else
+    #       fetch_preview_articles(object)
+    #     end
+    #   end
+    class Lookahead
+      # @param query [GraphQL::Query]
+      # @param ast_nodes [Array<GraphQL::Language::Nodes::Field>, Array<GraphQL::Language::Nodes::OperationDefinition>]
+      # @param field [GraphQL::Schema::Field] if `ast_nodes` are fields, this is the field definition matching those nodes
+      # @param root_type [Class] if `ast_nodes` are operation definition, this is the root type for that operation
+      def initialize(query:, ast_nodes:, field: nil, root_type: nil, owner_type: nil)
+        @ast_nodes = ast_nodes.freeze
+        @field = field
+        @root_type = root_type
+        @query = query
+        @selected_type = @field ? @field.type.unwrap : root_type
+        @owner_type = owner_type
+      end
+
+      # @return [Array<GraphQL::Language::Nodes::Field>]
+      attr_reader :ast_nodes
+
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
+      # @return [GraphQL::Schema::Object, GraphQL::Schema::Union, GraphQL::Schema::Interface]
+      attr_reader :owner_type
+
+      # @return [Hash<Symbol, Object>]
+      def arguments
+        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`.
+      # If `field_name` is a String, it is treated as a GraphQL-style (camelized)
+      # field name and used verbatim. If `field_name` is a Symbol, it is
+      # treated as a Ruby-style (underscored) name and camelized before comparing.
+      #
+      # If `arguments:` is provided, each provided key/value will be matched
+      # against the arguments in the next selection. This method will return false
+      # if any of the given `arguments:` are not present and matching in the next selection.
+      # (But, the next selection may contain _more_ than the given arguments.)
+      # @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?
+      end
+
+      # @return [Boolean] True if this lookahead represents a field that was requested
+      def selected?
+        true
+      end
+
+      # Like {#selects?}, but can be used for chaining.
+      # It returns a null object (check with {#selected?})
+      # @return [GraphQL::Execution::Lookahead]
+      def selection(field_name, selected_type: @selected_type, arguments: nil)
+        next_field_name = normalize_name(field_name)
+
+        next_field_defn = get_class_based_field(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)
+            end
+          end
+
+          if next_nodes.any?
+            Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+          else
+            NULL_LOOKAHEAD
+          end
+        else
+          NULL_LOOKAHEAD
+        end
+      end
+
+      # Like {#selection}, but for all nodes.
+      # It returns a list of Lookaheads for all Selections
+      #
+      # If `arguments:` is provided, each provided key/value will be matched
+      # against the arguments in each selection. This method will filter the selections
+      # if any of the given `arguments:` do not match the given selection.
+      #
+      # @example getting the name of a selection
+      #   def articles(lookahead:)
+      #     next_lookaheads = lookahead.selections # => [#<GraphQL::Execution::Lookahead ...>, ...]
+      #     next_lookaheads.map(&:name) #=> [:full_content, :title]
+      #   end
+      #
+      # @param arguments [Hash] Arguments which must match in the selection
+      # @return [Array<GraphQL::Execution::Lookahead>]
+      def selections(arguments: nil)
+        subselections_by_type = {}
+        subselections_on_type = subselections_by_type[@selected_type] = {}
+
+        @ast_nodes.each do |node|
+          find_selections(subselections_by_type, subselections_on_type, @selected_type, node.selections, arguments)
+        end
+
+        subselections = []
+
+        subselections_by_type.each do |type, ast_nodes_by_response_key|
+          ast_nodes_by_response_key.each do |response_key, ast_nodes|
+            field_defn = get_class_based_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
+        end
+
+        subselections
+      end
+
+      # The method name of the field.
+      # It returns the method_sym of the Lookahead's field.
+      #
+      # @example getting the name of a selection
+      #   def articles(lookahead:)
+      #     article.selection(:full_content).name # => :full_content
+      #     # ...
+      #   end
+      #
+      # @return [Symbol]
+      def name
+        @field && @field.original_name
+      end
+
+      def inspect
+        "#<GraphQL::Execution::Lookahead #{@field ? "@field=#{@field.path.inspect}": "@root_type=#{@root_type}"} @ast_nodes.size=#{@ast_nodes.size}>"
+      end
+
+      # This is returned for {Lookahead#selection} when a non-existent field is passed
+      class NullLookahead < Lookahead
+        # No inputs required here.
+        def initialize
+        end
+
+        def selected?
+          false
+        end
+
+        def selects?(*)
+          false
+        end
+
+        def selection(*)
+          NULL_LOOKAHEAD
+        end
+
+        def selections(*)
+          []
+        end
+
+        def inspect
+          "#<GraphQL::Execution::Lookahead::NullLookahead>"
+        end
+      end
+
+      # A singleton, so that misses don't come with overhead.
+      NULL_LOOKAHEAD = NullLookahead.new
+
+      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
+        end
+      end
+
+      # Wrap get_field and ensure that it returns a GraphQL::Schema::Field.
+      # Remove this when legacy execution is removed.
+      def get_class_based_field(type, name)
+        f = @query.get_field(type, name)
+        f && f.type_class
+      end
+
+      def skipped_by_directive?(ast_selection)
+        ast_selection.directives.each do |directive|
+          dir_defn = @query.schema.directives.fetch(directive.name)
+          directive_class = dir_defn.type_class
+          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
+            if selections_on_type.key?(response_key)
+              selections_on_type[response_key] << ast_selection
+            elsif arguments.nil? || arguments.empty?
+              selections_on_type[response_key] = [ast_selection]
+            else
+              field_defn = get_class_based_field(selected_type, ast_selection.name)
+              if arguments_match?(arguments, field_defn, ast_selection)
+                selections_on_type[response_key] = [ast_selection]
+              end
+            end
+          when GraphQL::Language::Nodes::InlineFragment
+            on_type = selected_type
+            subselections_on_type = selections_on_type
+            if (t = ast_selection.type)
+              # Assuming this is valid, that `t` will be found.
+              on_type = @query.get_type(t.name).type_class
+              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.get_type(frag_defn.type.name).type_class
+            subselections_on_type = subselections_by_type[on_type] ||= {}
+            find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
+          else
+            raise "Invariant: Unexpected selection type: #{ast_selection.class}"
+          end
+        end
+      end
+
+      # 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:)
+        return if skipped_by_directive?(node)
+        case node
+        when GraphQL::Language::Nodes::Field
+          if node.name == field_name
+            if arguments.nil? || arguments.empty?
+              # No constraint applied
+              matches << node
+            elsif arguments_match?(arguments, field_defn, node)
+              matches << node
+            end
+          end
+        when GraphQL::Language::Nodes::InlineFragment
+          node.selections.each { |s| find_selected_nodes(s, field_name, 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) }
+        else
+          raise "Unexpected selection comparison on #{node.class.name} (#{node})"
+        end
+      end
+
+      def arguments_match?(arguments, 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
+    end
+  end
+end