graphql_cody 1.13.0

data/lib/graphql/execution/multiplex.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Execute multiple queries under the same multiplex "umbrella".
+    # They can share a batching context and reduce redundant database hits.
+    #
+    # The flow is:
+    #
+    # - Multiplex instrumentation setup
+    # - Query instrumentation setup
+    # - Analyze the multiplex + each query
+    # - Begin each query
+    # - Resolve lazy values, breadth-first across all queries
+    # - Finish each query (eg, get errors)
+    # - Query instrumentation teardown
+    # - Multiplex instrumentation teardown
+    #
+    # If one query raises an application error, all queries will be in undefined states.
+    #
+    # Validation errors and {GraphQL::ExecutionError}s are handled in isolation:
+    # one of these errors in one query will not affect the other queries.
+    #
+    # @see {Schema#multiplex} for public API
+    # @api private
+    class Multiplex
+      # Used internally to signal that the query shouldn't be executed
+      # @api private
+      NO_OPERATION = {}.freeze
+
+      include Tracing::Traceable
+
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
+      def initialize(schema:, queries:, context:, max_complexity:)
+        @schema = schema
+        @queries = queries
+        @queries.each { |q| q.multiplex = self }
+        @context = context
+        @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
+        @tracers = schema.tracers + (context[:tracers] || [])
+        # Support `context: {backtrace: true}`
+        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
+          @tracers << GraphQL::Backtrace::Tracer
+        end
+        @max_complexity = max_complexity
+      end
+
+      class << self
+        def run_all(schema, query_options, **kwargs)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
+          run_queries(schema, queries, **kwargs)
+        end
+
+        # @param schema [GraphQL::Schema]
+        # @param queries [Array<GraphQL::Query>]
+        # @param context [Hash]
+        # @param max_complexity [Integer, nil]
+        # @return [Array<Hash>] One result per query
+        def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
+          multiplex = self.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
+            if supports_multiplexing?(schema)
+              instrument_and_analyze(multiplex) do
+                run_as_multiplex(multiplex)
+              end
+            else
+              if queries.length != 1
+                raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
+              else
+                instrument_and_analyze(multiplex) do
+                  [run_one_legacy(schema, queries.first)]
+                end
+              end
+            end
+          end
+        end
+
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
+        private
+
+        def run_as_multiplex(multiplex)
+
+          multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
+          queries = multiplex.queries
+          # Do as much eager evaluation of the query as possible
+          results = []
+          queries.each_with_index do |query, idx|
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
+          end
+
+          multiplex.dataloader.run
+
+          # Then, work through lazy results in a breadth-first way
+          multiplex.dataloader.append_job {
+            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          }
+          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]
+            finish_query(data_result, query, multiplex)
+            # 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
+        end
+
+        # @param data_result [Hash] The result for the "data" key, if any
+        # @param query [GraphQL::Query] The query which was run
+        # @return [Hash] final result of this query, including all values and errors
+        def finish_query(data_result, query, multiplex)
+          # 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
+            # Use `context.value` which was assigned during execution
+            result = query.schema.query_execution_strategy.finish_query(query, multiplex)
+
+            if query.context.errors.any?
+              error_result = query.context.errors.map(&:to_h)
+              result["errors"] = error_result
+            end
+
+            result
+          end
+        end
+
+        # use the old `query_execution_strategy` etc to run this query
+        def run_one_legacy(schema, query)
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+
+          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) }
+            else
+              nil
+            end
+          else
+            GraphQL::Query::Executor.new(query).result
+          end
+        end
+
+        DEFAULT_STRATEGIES = [
+          GraphQL::Execution::Execute,
+          GraphQL::Execution::Interpreter
+        ]
+        # @return [Boolean] True if the schema is only using one strategy, and it's one that supports multiplexing.
+        def supports_multiplexing?(schema)
+          schema_strategies = [schema.query_execution_strategy, schema.mutation_execution_strategy, schema.subscription_execution_strategy]
+          schema_strategies.uniq!
+          schema_strategies.size == 1 && DEFAULT_STRATEGIES.include?(schema_strategies.first)
+        end
+
+        # Apply multiplex & query instrumentation to `queries`.
+        #
+        # It yields when the queries should be executed, then runs teardown.
+        def instrument_and_analyze(multiplex)
+          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
+            schema = multiplex.schema
+            if schema.interpreter? && schema.analysis_engine != GraphQL::Analysis::AST
+              raise <<-ERR
+Can't use `GraphQL::Execution::Interpreter` without `GraphQL::Analysis::AST`, please add this plugin to your schema:
+
+    use GraphQL::Analysis::AST
+
+For information about the new analysis engine: https://graphql-ruby.org/queries/ast_analysis.html
+ERR
+            end
+            multiplex_analyzers = schema.multiplex_analyzers
+            if multiplex.max_complexity
+              multiplex_analyzers += if schema.using_ast_analysis?
+                [GraphQL::Analysis::AST::MaxQueryComplexity]
+              else
+                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              end
+            end
+
+            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/typecast.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # @api private
+    module Typecast
+      # @return [Boolean]
+      def self.subtype?(parent_type, child_type)
+        if parent_type == child_type
+          # Equivalent types are subtypes
+          true
+        elsif child_type.is_a?(GraphQL::NonNullType)
+          # A non-null type is a subtype of a nullable type
+          # if its inner type is a subtype of that type
+          if parent_type.is_a?(GraphQL::NonNullType)
+            subtype?(parent_type.of_type, child_type.of_type)
+          else
+            subtype?(parent_type, child_type.of_type)
+          end
+        else
+          case parent_type
+          when GraphQL::InterfaceType
+            # A type is a subtype of an interface
+            # if it implements that interface
+            case child_type
+            when GraphQL::ObjectType
+              child_type.interfaces.include?(parent_type)
+            else
+              false
+            end
+          when GraphQL::UnionType
+            # A type is a subtype of that union
+            # if the union includes that type
+            parent_type.possible_types.include?(child_type)
+          when GraphQL::ListType
+            # A list type is a subtype of another list type
+            # if its inner type is a subtype of the other inner type
+            case child_type
+            when GraphQL::ListType
+              subtype?(parent_type.of_type, child_type.of_type)
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "graphql/execution/directive_checks"
+require "graphql/execution/execute"
+require "graphql/execution/flatten"
+require "graphql/execution/instrumentation"
+require "graphql/execution/interpreter"
+require "graphql/execution/lazy"
+require "graphql/execution/lookahead"
+require "graphql/execution/multiplex"
+require "graphql/execution/typecast"
+require "graphql/execution/errors"

data/lib/graphql/execution_error.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module GraphQL
+  # If a field's resolve function returns a {ExecutionError},
+  # the error will be inserted into the response's `"errors"` key
+  # and the field will resolve to `nil`.
+  class ExecutionError < GraphQL::Error
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_accessor :ast_node
+
+    # @return [String] an array describing the JSON-path into the execution
+    # response which corresponds to this error.
+    attr_accessor :path
+
+    # @return [Hash] Optional data for error objects
+    # @deprecated Use `extensions` instead of `options`. The GraphQL spec
+    # recommends that any custom entries in an error be under the
+    # `extensions` key.
+    attr_accessor :options
+
+    # @return [Hash] Optional custom data for error objects which will be added
+    # under the `extensions` key.
+    attr_accessor :extensions
+
+    def initialize(message, ast_node: nil, options: nil, extensions: nil)
+      @ast_node = ast_node
+      @options = options
+      @extensions = extensions
+      super(message)
+    end
+
+    # @return [Hash] An entry for the response's "errors" key
+    def to_h
+      hash = {
+        "message" => message,
+      }
+      if ast_node
+        hash["locations"] = [
+          {
+            "line" => ast_node.line,
+            "column" => ast_node.col,
+          }
+        ]
+      end
+      if path
+        hash["path"] = path
+      end
+      if options
+        hash.merge!(options)
+      end
+      if extensions
+        hash["extensions"] = extensions.each_with_object({}) { |(key, value), ext|
+          ext[key.to_s] = value
+        }
+      end
+      hash
+    end
+  end
+end

data/lib/graphql/field/resolve.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module GraphQL
+  class Field
+    # Create resolve procs ahead of time based on a {GraphQL::Field}'s `name`, `property`, and `hash_key` configuration.
+    module Resolve
+      module_function
+
+      # @param field [GraphQL::Field] A field that needs a resolve proc
+      # @return [Proc] A resolver for this field, based on its config
+      def create_proc(field)
+        if field.property
+          MethodResolve.new(field)
+        elsif !field.hash_key.nil?
+          HashKeyResolve.new(field.hash_key)
+        else
+          NameResolve.new(field)
+        end
+      end
+
+      # These only require `obj` as input
+      class BuiltInResolve
+      end
+
+      # Resolve the field by `public_send`ing `@method_name`
+      class MethodResolve < BuiltInResolve
+        def initialize(field)
+          @method_name = field.property.to_sym
+        end
+
+        def call(obj, args, ctx)
+          obj.public_send(@method_name)
+        end
+      end
+
+      # Resolve the field by looking up `@hash_key` with `#[]`
+      class HashKeyResolve < BuiltInResolve
+        def initialize(hash_key)
+          @hash_key = hash_key
+        end
+
+        def call(obj, args, ctx)
+          obj[@hash_key]
+        end
+      end
+
+      # Call the field's name at query-time since
+      # it might have changed
+      class NameResolve < BuiltInResolve
+        def initialize(field)
+          @field = field
+        end
+
+        def call(obj, args, ctx)
+          obj.public_send(@field.name)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/field.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+require "graphql/field/resolve"
+
+module GraphQL
+  # @api deprecated
+  class Field
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions :name, :description, :deprecation_reason,
+      :resolve, :lazy_resolve,
+      :type, :arguments,
+      :property, :hash_key, :complexity,
+      :mutation, :function,
+      :edge_class,
+      :relay_node_field,
+      :relay_nodes_field,
+      :subscription_scope,
+      :trace,
+      :introspection,
+      argument: GraphQL::Define::AssignArgument
+
+    ensure_defined(
+      :name, :deprecation_reason, :description, :description=, :property, :hash_key,
+      :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,
+      :introspection?
+    )
+
+    # @return [Boolean] True if this is the Relay find-by-id field
+    attr_accessor :relay_node_field
+
+    # @return [Boolean] True if this is the Relay find-by-ids field
+    attr_accessor :relay_nodes_field
+
+    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called to return the field's value
+    attr_reader :resolve_proc
+
+    # @return [<#call(obj, args, ctx)>] A proc-like object which can be called trigger a lazy resolution
+    attr_reader :lazy_resolve_proc
+
+    # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
+    attr_reader :name
+    alias :graphql_name :name
+
+    # @return [String, nil] The client-facing description of this field
+    attr_accessor :description
+
+    # @return [String, nil] The client-facing reason why this field is deprecated (if present, the field is deprecated)
+    attr_accessor :deprecation_reason
+
+    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
+    attr_accessor :arguments
+
+    # @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    attr_accessor :mutation
+
+    # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `->(query_ctx, args, child_complexity) { } # Numeric`
+    attr_accessor :complexity
+
+    # @return [Symbol, nil] The method to call on `obj` to return this field (overrides {#name} if present)
+    attr_reader :property
+
+    # @return [Object, nil] The key to access with `obj.[]` to resolve this field (overrides {#name} if present)
+    attr_reader :hash_key
+
+    # @return [Object, GraphQL::Function] The function used to derive this field
+    attr_accessor :function
+
+    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
+
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
+    # @return [Boolean]
+    def connection?
+      @connection
+    end
+
+    # @return [nil, Class]
+    # @api private
+    attr_accessor :edge_class
+
+    # @return [Boolean]
+    def edges?
+      !!@edge_class
+    end
+
+    # @return [nil, Integer]
+    attr_accessor :connection_max_page_size
+
+    def initialize
+      @complexity = 1
+      @arguments = {}
+      @resolve_proc = build_default_resolver
+      @lazy_resolve_proc = DefaultLazyResolve
+      @relay_node_field = false
+      @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)
+    #
+    # @param object [Object] The object this field belongs to
+    # @param arguments [Hash] Arguments declared in the query
+    # @param context [GraphQL::Query::Context]
+    def resolve(object, arguments, context)
+      resolve_proc.call(object, arguments, context)
+    end
+
+    # Provide a new callable for this field's resolve function. If `nil`,
+    # a new resolve proc will be build based on its {#name}, {#property} or {#hash_key}.
+    # @param new_resolve_proc [<#call(obj, args, ctx)>, nil]
+    def resolve=(new_resolve_proc)
+      @resolve_proc = new_resolve_proc || build_default_resolver
+    end
+
+    def type=(new_return_type)
+      @clean_type = nil
+      @dirty_type = new_return_type
+    end
+
+    # Get the return type for this field.
+    def type
+      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
+    end
+
+    def name=(new_name)
+      old_name = defined?(@name) ? @name : nil
+      @name = new_name
+
+      if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
+        # Since the NameResolve would use the old field name,
+        # reset resolve proc when the name has changed
+        self.resolve = nil
+      end
+    end
+
+    # @param new_property [Symbol] A method to call to resolve this field. Overrides the existing resolve proc.
+    def property=(new_property)
+      @property = new_property
+      self.resolve = nil # reset resolve proc
+    end
+
+    # @param new_hash_key [Symbol] A key to access with `#[key]` to resolve this field. Overrides the existing resolve proc.
+    def hash_key=(new_hash_key)
+      @hash_key = new_hash_key
+      self.resolve = nil # reset resolve proc
+    end
+
+    def to_s
+      "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
+    end
+
+    # 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
+    # @return [Object] The result of calling the registered method on `obj`
+    def lazy_resolve(obj, args, ctx)
+      @lazy_resolve_proc.call(obj, args, ctx)
+    end
+
+    # Assign a new resolve proc to this field. Used for {#lazy_resolve}
+    def lazy_resolve=(new_lazy_resolve_proc)
+      @lazy_resolve_proc = new_lazy_resolve_proc
+    end
+
+    # Prepare a lazy value for this field. It may be `then`-ed and resolved later.
+    # @return [GraphQL::Execution::Lazy] A lazy wrapper around `obj` and its registered method name
+    def prepare_lazy(obj, args, ctx)
+      GraphQL::Execution::Lazy.new {
+        lazy_resolve(obj, args, ctx)
+      }
+    end
+
+    def type_class
+      metadata[:type_class]
+    end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
+    private
+
+    def build_default_resolver
+      GraphQL::Field::Resolve.create_proc(self)
+    end
+
+    module DefaultLazyResolve
+      def self.call(obj, args, ctx)
+        ctx.schema.sync_lazy(obj)
+      end
+    end
+  end
+end

data/lib/graphql/filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api private
+  class Filter
+    def initialize(only: nil, except: nil)
+      @only = only
+      @except = except
+    end
+
+    # Returns true if `member, ctx` passes this filter
+    def call(member, ctx)
+      (@only ? @only.call(member, ctx) : true) &&
+      (@except ? !@except.call(member, ctx) : true)
+    end
+
+    def merge(only: nil, except: nil)
+      onlies = [self].concat(Array(only))
+      merged_only = MergedOnly.build(onlies)
+      merged_except = MergedExcept.build(Array(except))
+      self.class.new(only: merged_only, except: merged_except)
+    end
+
+    private
+
+    class MergedOnly
+      def initialize(first, second)
+        @first = first
+        @second = second
+      end
+
+      def call(member, ctx)
+        @first.call(member, ctx) && @second.call(member, ctx)
+      end
+
+      def self.build(onlies)
+        case onlies.size
+        when 0
+          nil
+        when 1
+          onlies[0]
+        else
+          onlies.reduce { |memo, only| self.new(memo, only) }
+        end
+      end
+    end
+
+    class MergedExcept < MergedOnly
+      def call(member, ctx)
+        @first.call(member, ctx) || @second.call(member, ctx)
+      end
+    end
+  end
+end

data/lib/graphql/float_type.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition