graphql_cody 1.13.0

data/lib/graphql/backtrace/table.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # A class for turning a context into a human-readable table or array
+    class Table
+      MIN_COL_WIDTH = 4
+      MAX_COL_WIDTH = 100
+      HEADERS = [
+        "Loc",
+        "Field",
+        "Object",
+        "Arguments",
+        "Result",
+      ]
+
+      def initialize(context, value:)
+        @context = context
+        @override_value = value
+      end
+
+      # @return [String] A table layout of backtrace with metadata
+      def to_table
+        @to_table ||= render_table(rows)
+      end
+
+      # @return [Array<String>] An array of position + field name entries
+      def to_backtrace
+        @to_backtrace ||= begin
+          backtrace = rows.map { |r| "#{r[0]}: #{r[1]}" }
+          # skip the header entry
+          backtrace.shift
+          backtrace
+        end
+      end
+
+      private
+
+      def rows
+        @rows ||= build_rows(@context, rows: [HEADERS], top: true)
+      end
+
+      # @return [String]
+      def render_table(rows)
+        max = Array.new(HEADERS.length, MIN_COL_WIDTH)
+
+        rows.each do |row|
+          row.each_with_index do |col, idx|
+            col_len = col.length
+            max_len = max[idx]
+            if col_len > max_len
+              if col_len > MAX_COL_WIDTH
+                max[idx] = MAX_COL_WIDTH
+              else
+                max[idx] = col_len
+              end
+            end
+          end
+        end
+
+        table = "".dup
+        last_col_idx = max.length - 1
+        rows.each do |row|
+          table << row.map.each_with_index do |col, idx|
+            max_len = max[idx]
+            if idx < last_col_idx
+              col = col.ljust(max_len)
+            end
+            if col.length > max_len
+              col = col[0, max_len - 3] + "..."
+            end
+            col
+          end.join(" | ")
+          table << "\n"
+        end
+        table
+      end
+
+      # @return [Array] 5 items for a backtrace table (not `key`)
+      def build_rows(context_entry, rows:, top: false)
+        case context_entry
+        when Backtrace::Frame
+          field_alias = context_entry.ast_node.respond_to?(:alias) && context_entry.ast_node.alias
+          value = if top && @override_value
+            @override_value
+          else
+            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
+          end
+          rows << [
+            "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
+            "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
+            "#{context_entry.object.object.inspect}",
+            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
+            Backtrace::InspectResult.inspect_result(value),
+          ]
+          if (parent = context_entry.parent_frame)
+            build_rows(parent, rows: rows)
+          else
+            rows
+          end
+        when GraphQL::Query::Context::FieldResolutionContext
+          ctx = context_entry
+          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
+          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
+          field_alias = ctx.ast_node.alias
+          object = ctx.object
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
+          rows << [
+            "#{position}",
+            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
+            "#{object.inspect}",
+            ctx.irep_node.arguments.to_h.inspect,
+            Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
+          ]
+
+          build_rows(ctx.parent, rows: rows)
+        when GraphQL::Query::Context
+          query = context_entry.query
+          op = query.selected_operation
+          if op
+            op_type = op.operation_type
+            position = "#{op.line}:#{op.col}"
+          else
+            op_type = "query"
+            position = "?:?"
+          end
+          op_name = query.selected_operation_name
+          object = query.root_value
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
+          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
+          rows << [
+            "#{position}",
+            "#{op_type}#{op_name ? " #{op_name}" : ""}",
+            "#{object.inspect}",
+            query.variables.to_h.inspect,
+            Backtrace::InspectResult.inspect_result(value),
+          ]
+        else
+          raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
+        end
+      end
+
+      def value_at(runtime, path)
+        response = runtime.final_result
+        path.each do |key|
+          if response && (response = response[key])
+            next
+          else
+            break
+          end
+        end
+        response
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/traced_error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.
+    class TracedError < GraphQL::Error
+      # @return [Array<String>] Printable backtrace of GraphQL error context
+      attr_reader :graphql_backtrace
+
+      # @return [GraphQL::Query::Context] The context at the field where the error was raised
+      attr_reader :context
+
+      MESSAGE_TEMPLATE = <<-MESSAGE
+Unhandled error during GraphQL execution:
+
+  %{cause_message}
+    %{cause_backtrace}
+    %{cause_backtrace_more}
+Use #cause to access the original exception (including #cause.backtrace).
+
+GraphQL Backtrace:
+%{graphql_table}
+MESSAGE
+
+      # This many lines of the original Ruby backtrace
+      # are included in the message
+      CAUSE_BACKTRACE_PREVIEW_LENGTH = 10
+
+      def initialize(err, current_ctx)
+        @context = current_ctx
+        backtrace = Backtrace.new(current_ctx, value: err)
+        @graphql_backtrace = backtrace.to_a
+
+        cause_backtrace_preview = err.backtrace.first(CAUSE_BACKTRACE_PREVIEW_LENGTH).join("\n    ")
+
+        cause_backtrace_remainder_length = err.backtrace.length - CAUSE_BACKTRACE_PREVIEW_LENGTH
+        cause_backtrace_more = if cause_backtrace_remainder_length < 0
+          ""
+        elsif cause_backtrace_remainder_length == 1
+          "... and 1 more line\n"
+        else
+          "... and #{cause_backtrace_remainder_length} more lines\n"
+        end
+
+        message = MESSAGE_TEMPLATE % {
+          cause_message: err.message,
+          cause_backtrace: cause_backtrace_preview,
+          cause_backtrace_more: cause_backtrace_more,
+          graphql_table: backtrace.inspect,
+        }
+        super(message)
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/tracer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # TODO this is not fiber-friendly
+    module Tracer
+      module_function
+
+      # Implement the {GraphQL::Tracing} API.
+      def trace(key, metadata)
+        case key
+        when "lex", "parse"
+          # No context here, don't have a query yet
+          nil
+        when "execute_multiplex", "analyze_multiplex"
+          # No query context yet
+          nil
+        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
+          push_key = []
+          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
+            push_data = query
+            multiplex = query.multiplex
+          elsif (multiplex = metadata[:multiplex])
+            push_data = multiplex.queries.first
+          end
+        when "execute_field", "execute_field_lazy"
+          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          multiplex = query.multiplex
+          push_key = metadata[:path]
+          parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
+
+          if parent_frame.is_a?(GraphQL::Query)
+            parent_frame = parent_frame.context
+          end
+
+          push_data = Frame.new(
+            query: query,
+            path: push_key,
+            ast_node: metadata[:ast_node],
+            field: metadata[:field],
+            object: metadata[:object],
+            arguments: metadata[:arguments],
+            parent_frame: parent_frame,
+          )
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data && multiplex
+          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+          push_storage[push_key] = push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          multiplex_context = metadata[:multiplex].context
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = multiplex_context[:last_graphql_backtrace_context]
+
+            if potential_context.is_a?(GraphQL::Query::Context) ||
+                potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext) ||
+                potential_context.is_a?(Backtrace::Frame)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
+            end
+          ensure
+            multiplex_context.delete(:graphql_backtrace_contexts)
+            multiplex_context.delete(:last_graphql_backtrace_context)
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "graphql/backtrace/inspect_result"
+require "graphql/backtrace/legacy_tracer"
+require "graphql/backtrace/table"
+require "graphql/backtrace/traced_error"
+require "graphql/backtrace/tracer"
+module GraphQL
+  # Wrap unhandled errors with {TracedError}.
+  #
+  # {TracedError} provides a GraphQL backtrace with arguments and return values.
+  # The underlying error is available as {TracedError#cause}.
+  #
+  # @example toggling backtrace annotation
+  #   class MySchema < GraphQL::Schema
+  #     if Rails.env.development? || Rails.env.test?
+  #       use GraphQL::Backtrace
+  #     end
+  #   end
+  #
+  class Backtrace
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :to_a, :each, :[]
+
+    def self.use(schema_defn, legacy: false)
+      tracer = if legacy
+        self::LegacyTracer
+      else
+        self::Tracer
+      end
+      schema_defn.tracer(tracer)
+    end
+
+    def initialize(context, value: nil)
+      @table = Table.new(context, value: value)
+    end
+
+    def inspect
+      @table.to_table
+    end
+
+    alias :to_s :inspect
+
+    def to_a
+      @table.to_backtrace
+    end
+
+    # Used for internal bookkeeping
+    # @api private
+    class Frame
+      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
+      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
+        @path = path
+        @query = query
+        @ast_node = ast_node
+        @field = field
+        @object = object
+        @arguments = arguments
+        @parent_frame = parent_frame
+      end
+    end
+  end
+end

data/lib/graphql/backwards_compatibility.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module GraphQL
+  # Helpers for migrating in a backwards-compatible way
+  # Remove this in GraphQL-Ruby 2.0, when all users of it will be gone.
+  # @api private
+  module BackwardsCompatibility
+    module_function
+    # Given a callable whose API used to take `from` arguments,
+    # check its arity, and if needed, apply a wrapper so that
+    # it can be called with `to` arguments.
+    # If a wrapper is applied, warn the application with `name`.
+    #
+    # If `last`, then use the last arguments to call the function.
+    def wrap_arity(callable, from:, to:, name:, last: false)
+      arity = get_arity(callable)
+      if arity == to || arity < 0
+        # It already matches, return it as is
+        callable
+      elsif arity == from
+        # It has the old arity, so wrap it with an arity converter
+        message ="#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments, see:"
+        backtrace = caller(0, 20)
+        # Find the first line in the trace that isn't library internals:
+        user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
+        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
+        wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
+        wrapper.new(callable, from)
+      else
+        raise "Can't wrap #{callable} (arity: #{arity}) to have arity #{to}"
+      end
+    end
+
+    def get_arity(callable)
+      case callable
+      when Method, Proc
+        callable.arity
+      else
+        callable.method(:call).arity
+      end
+    end
+
+    class FirstArgumentsWrapper
+      def initialize(callable, old_arity)
+        @callable = callable
+        @old_arity = old_arity
+      end
+
+      def call(*args)
+        backwards_compat_args = args.first(@old_arity)
+        @callable.call(*backwards_compat_args)
+      end
+    end
+
+    class LastArgumentsWrapper < FirstArgumentsWrapper
+      def call(*args)
+        backwards_compat_args = args.last(@old_arity)
+        @callable.call(*backwards_compat_args)
+      end
+    end
+  end
+end

data/lib/graphql/base_type.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+require "graphql/relay/type_extensions"
+
+module GraphQL
+  # The parent for all type classes.
+  class BaseType
+    include GraphQL::Define::NonNullWithBang
+    include GraphQL::Define::InstanceDefinable
+    include GraphQL::Relay::TypeExtensions
+
+    accepts_definitions :name, :description,
+        :introspection,
+        :default_scalar,
+        :default_relay,
+        {
+          connection: GraphQL::Define::AssignConnection,
+          global_id_field: GraphQL::Define::AssignGlobalIdField,
+        }
+
+    ensure_defined(:graphql_name, :name, :description, :introspection?, :default_scalar?)
+
+    attr_accessor :ast_node
+
+    def initialize
+      @introspection = false
+      @default_scalar = false
+      @default_relay = false
+    end
+
+    def initialize_copy(other)
+      super
+      # Reset these derived defaults
+      @connection_type = nil
+      @edge_type = nil
+    end
+
+    # @return [String] the name of this type, must be unique within a Schema
+    attr_reader :name
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
+    def type_class
+      metadata[:type_class]
+    end
+
+    def name=(name)
+      GraphQL::NameValidator.validate!(name)
+      @name = name
+    end
+
+    # @return [String, nil] a description for this type
+    attr_accessor :description
+
+    # @return [Boolean] Is this type a predefined introspection type?
+    def introspection?
+      @introspection
+    end
+
+    # @return [Boolean] Is this type a built-in scalar type? (eg, `String`, `Int`)
+    def default_scalar?
+      @default_scalar
+    end
+
+    # @return [Boolean] Is this type a built-in Relay type? (`Node`, `PageInfo`)
+    def default_relay?
+      @default_relay
+    end
+
+    # @api private
+    attr_writer :introspection, :default_scalar, :default_relay
+
+    # @param other [GraphQL::BaseType] compare to this object
+    # @return [Boolean] are these types equivalent? (incl. non-null, list)
+    # @see {ModifiesAnotherType#==} for override on List & NonNull types
+    def ==(other)
+      other.is_a?(GraphQL::BaseType) && self.name == other.name
+    end
+
+    # If this type is modifying an underlying type,
+    # return the underlying type. (Otherwise, return `self`.)
+    def unwrap
+      self
+    end
+
+    # @return [GraphQL::NonNullType] a non-null version of this type
+    def to_non_null_type
+      GraphQL::NonNullType.new(of_type: self)
+    end
+
+    # @return [GraphQL::ListType] a list version of this type
+    def to_list_type
+      GraphQL::ListType.new(of_type: self)
+    end
+
+    module ModifiesAnotherType
+      def unwrap
+        self.of_type.unwrap
+      end
+
+      def ==(other)
+        other.is_a?(ModifiesAnotherType) && other.of_type == of_type
+      end
+    end
+
+    # Find out which possible type to use for `value`.
+    # Returns self if there are no possible types (ie, not Union or Interface)
+    def resolve_type(value, ctx)
+      self
+    end
+
+    # Print the human-readable name of this type using the query-string naming pattern
+    def to_s
+      name
+    end
+
+    alias :inspect :to_s
+    alias :to_type_signature :to_s
+
+    def valid_isolated_input?(value)
+      valid_input?(value, GraphQL::Query::NullContext)
+    end
+
+    def validate_isolated_input(value)
+      validate_input(value, GraphQL::Query::NullContext)
+    end
+
+    def coerce_isolated_input(value)
+      coerce_input(value, GraphQL::Query::NullContext)
+    end
+
+    def coerce_isolated_result(value)
+      coerce_result(value, GraphQL::Query::NullContext)
+    end
+
+    def valid_input?(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("valid_isolated_input?")
+        ctx = GraphQL::Query::NullContext
+      end
+
+      validate_input(value, ctx).valid?
+    end
+
+    def validate_input(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("validate_isolated_input")
+        ctx = GraphQL::Query::NullContext
+      end
+
+      if value.nil?
+        GraphQL::Query::InputValidationResult.new
+      else
+        validate_non_null_input(value, ctx)
+      end
+    end
+
+    def coerce_input(value, ctx = nil)
+      if value.nil?
+        nil
+      else
+        if ctx.nil?
+          warn_deprecated_coerce("coerce_isolated_input")
+          ctx = GraphQL::Query::NullContext
+        end
+        coerce_non_null_input(value, ctx)
+      end
+    end
+
+    def coerce_result(value, ctx)
+      raise GraphQL::RequiredImplementationMissingError
+    end
+
+    # Types with fields may override this
+    # @param name [String] field name to lookup for this type
+    # @return [GraphQL::Field, nil]
+    def get_field(name)
+      nil
+    end
+
+    # During schema definition, types can be defined inside procs or as strings.
+    # This function converts it to a type instance
+    # @return [GraphQL::BaseType]
+    def self.resolve_related_type(type_arg)
+      case type_arg
+      when Proc
+        # lazy-eval it, then try again
+        resolve_related_type(type_arg.call)
+      when String
+        # Get a constant by this name
+        resolve_related_type(Object.const_get(type_arg))
+      else
+        if type_arg.respond_to?(:graphql_definition)
+          type_arg.graphql_definition
+        else
+          type_arg
+        end
+      end
+    end
+
+    # Return a GraphQL string for the type definition
+    # @param schema [GraphQL::Schema]
+    # @param printer [GraphQL::Schema::Printer]
+    # @see {GraphQL::Schema::Printer#initialize for additional options}
+    # @return [String] type definition
+    def to_definition(schema, printer: nil, **args)
+      printer ||= GraphQL::Schema::Printer.new(schema, **args)
+      printer.print_type(self)
+    end
+
+    # Returns true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
+    def non_null?
+      false
+    end
+
+    # Returns true if this is a list type. A non-nullable list is considered a list.
+    def list?
+      false
+    end
+
+    private
+
+    def warn_deprecated_coerce(alt_method_name)
+      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
+    end
+  end
+end

data/lib/graphql/boolean_type.rb

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

data/lib/graphql/coercion_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GraphQL
+  class CoercionError < GraphQL::Error
+    # @return [Hash] Optional custom data for error objects which will be added
+    # under the `extensions` key.
+    attr_accessor :extensions
+
+    def initialize(message, extensions: nil)
+      @extensions = extensions
+      super(message)
+    end
+  end
+end