graphql_cody 1.13.0

data/lib/graphql/enum_type.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api deprecated
+  class EnumType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
+    ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
+    attr_accessor :ast_node
+
+    def initialize
+      super
+      @values_by_name = {}
+    end
+
+    def initialize_copy(other)
+      super
+      self.values = other.values.values
+    end
+
+    # @param new_values [Array<EnumValue>] The set of values contained in this type
+    def values=(new_values)
+      @values_by_name = {}
+      new_values.each { |enum_value| add_value(enum_value) }
+    end
+
+    # @param enum_value [EnumValue] A value to add to this type's set of values
+    def add_value(enum_value)
+      if @values_by_name.key?(enum_value.name)
+        raise "Enum value names must be unique. Value `#{enum_value.name}` already exists on Enum `#{name}`."
+      end
+
+      @values_by_name[enum_value.name] = enum_value
+    end
+
+    # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
+    def values(_context = nil)
+      @values_by_name
+    end
+
+    def enum_values(_context = nil)
+      values.values
+    end
+
+    def kind
+      GraphQL::TypeKinds::ENUM
+    end
+
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
+      end
+
+      warden = ctx.warden
+      all_values = warden ? warden.enum_values(self) : @values_by_name.each_value
+      enum_value = all_values.find { |val| val.value == value }
+      if enum_value
+        enum_value.name
+      else
+        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value.inspect}")
+      end
+    end
+
+    def to_s
+      name
+    end
+
+    # A value within an {EnumType}
+    #
+    # Created with the `value` helper
+    class EnumValue
+      include GraphQL::Define::InstanceDefinable
+      ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
+      accepts_definitions(*ATTRIBUTES)
+      attr_accessor(*ATTRIBUTES)
+      attr_accessor :ast_node
+      ensure_defined(*ATTRIBUTES)
+
+      undef name=
+      def name=(new_name)
+        # Validate that the name is correct
+        GraphQL::NameValidator.validate!(new_name)
+        @name = new_name
+      end
+
+      def graphql_name
+        name
+      end
+
+      def type_class
+        metadata[:type_class]
+      end
+    end
+
+    class UnresolvedValueError < GraphQL::Error
+    end
+
+    private
+
+    # Get the underlying value for this enum value
+    #
+    # @example get episode value from Enum
+    #   episode = EpisodeEnum.coerce("NEWHOPE")
+    #   episode # => 6
+    #
+    # @param value_name [String] the string representation of this enum value
+    # @return [Object] the underlying value for this enum value
+    def coerce_non_null_input(value_name, ctx)
+      if @values_by_name.key?(value_name)
+        @values_by_name.fetch(value_name).value
+      elsif match_by_value = @values_by_name.find { |k, v| v.value == value_name }
+        # this is for matching default values, which are "inputs", but they're
+        # the Ruby value, not the GraphQL string.
+        match_by_value[1].value
+      else
+        nil
+      end
+    end
+
+    def validate_non_null_input(value_name, ctx)
+      result = GraphQL::Query::InputValidationResult.new
+      allowed_values = ctx.warden.enum_values(self)
+      matching_value = allowed_values.find { |v| v.name == value_name }
+
+      if matching_value.nil?
+        result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:name).join(', ')}")
+      end
+
+      result
+    end
+  end
+end

data/lib/graphql/execution/directive_checks.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Boolean checks for how an AST node's directives should
+    # influence its execution
+    # @api private
+    module DirectiveChecks
+      SKIP = "skip"
+      INCLUDE = "include"
+
+      module_function
+
+      # @return [Boolean] Should this node be included in the query?
+      def include?(directive_ast_nodes, query)
+        directive_ast_nodes.each do |directive_ast_node|
+          name = directive_ast_node.name
+          directive_defn = query.schema.directives[name]
+          case name
+          when SKIP
+            args = query.arguments_for(directive_ast_node, directive_defn)
+            if args[:if] == true
+              return false
+            end
+          when INCLUDE
+            args = query.arguments_for(directive_ast_node, directive_defn)
+            if args[:if] == false
+              return false
+            end
+          else
+            # Undefined directive, or one we don't care about
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/graphql/execution/errors.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    # A plugin that wraps query execution with error handling.
+    # Supports class-based schemas and the new {Interpreter} runtime only.
+    #
+    # @example Handling ActiveRecord::NotFound
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Execution::Errors
+    #
+    #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
+    #       ErrorTracker.log("Not Found: #{err.message}")
+    #       nil
+    #     end
+    #   end
+    #
+    class Errors
+      def self.use(schema)
+        definition_line = caller(2, 1).first
+        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
+      end
+
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
+      def initialize(schema)
+        @schema = schema
+        @handlers = {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
+      end
+
+      # @api private
+      def each_rescue
+        handlers = @handlers.values
+        while (handler = handlers.shift) do
+          yield(handler[:class], handler[:handler])
+          handlers.concat(handler[:subclass_handlers].values)
+        end
+      end
+
+      # Register this handler, updating the
+      # internal handler index to maintain least-to-most specific.
+      #
+      # @param error_class [Class<Exception>]
+      # @param error_handler [Proc]
+      # @return [void]
+      def rescue_from(error_class, error_handler)
+        subclasses_handlers = {}
+        this_level_subclasses = []
+        # During this traversal, do two things:
+        # - Identify any already-registered subclasses of this error class
+        #   and gather them up to be inserted _under_ this class
+        # - Find the point in the index where this handler should be inserted
+        #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
+        handlers = @handlers[:subclass_handlers]
+        while (handlers) do
+          this_level_subclasses.clear
+          # First, identify already-loaded handlers that belong
+          # _under_ this one. (That is, they're handlers
+          # for subclasses of `error_class`.)
+          handlers.each do |err_class, handler|
+            if err_class < error_class
+              subclasses_handlers[err_class] = handler
+              this_level_subclasses << err_class
+            end
+          end
+          # Any handlers that we'll be moving, delete them from this point in the index
+          this_level_subclasses.each do |err_class|
+            handlers.delete(err_class)
+          end
+
+          # See if any keys in this hash are superclasses of this new class:
+          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          if next_index_point
+            handlers = next_index_point[1][:subclass_handlers]
+          else
+            # this new handler doesn't belong to any sub-handlers,
+            # so insert it in the current set of `handlers`
+            break
+          end
+        end
+        # Having found the point at which to insert this handler,
+        # register it and merge any subclass handlers back in at this point.
+        this_class_handlers = handlers[error_class]
+        this_class_handlers[:handler] = error_handler
+        this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+        nil
+      end
+
+      # Call the given block with the schema's configured error handlers.
+      #
+      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
+      #
+      # @param ctx [GraphQL::Query::Context]
+      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
+      def with_error_handling(ctx)
+        yield
+      rescue StandardError => err
+        handler = find_handler_for(err.class)
+        if handler
+          runtime_info = ctx.namespace(:interpreter) || {}
+          obj = runtime_info[:current_object]
+          args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
+          field = runtime_info[:current_field]
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          handler[:handler].call(err, obj, args, ctx, field)
+        else
+          raise err
+        end
+      end
+
+      # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
+      def find_handler_for(error_class)
+        handlers = @handlers[:subclass_handlers]
+        handler = nil
+        while (handlers) do
+          _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
+          if next_handler
+            handlers = next_handler[:subclass_handlers]
+            handler = next_handler
+          else
+            # Don't reassign `handler` --
+            # let the previous assignment carry over outside this block.
+            break
+          end
+        end
+
+        # check for a handler from a parent class:
+        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
+          parent_handler = parent_errors.find_handler_for(error_class)
+        end
+
+        # If the inherited handler is more specific than the one defined here,
+        # use it.
+        # If it's a tie (or there is no parent handler), use the one defined here.
+        # If there's an inherited one, but not one defined here, use the inherited one.
+        # Otherwise, there's no handler for this error, return `nil`.
+        if parent_handler && handler && parent_handler[:class] < handler[:class]
+          parent_handler
+        elsif handler
+          handler
+        elsif parent_handler
+          parent_handler
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/execute.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # A valid execution strategy
+    # @api private
+    class Execute
+
+      # @api private
+      class Skip < GraphQL::Error; end
+
+      # Just a singleton for implementing {Query::Context#skip}
+      # @api private
+      SKIP = Skip.new
+
+      # @api private
+      class PropagateNull
+      end
+      # @api private
+      PROPAGATE_NULL = PropagateNull.new
+
+      def self.use(schema_class)
+        schema_class.query_execution_strategy(self)
+        schema_class.mutation_execution_strategy(self)
+        schema_class.subscription_execution_strategy(self)
+      end
+
+      def execute(ast_operation, root_type, query)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
+        result = resolve_root_selection(query)
+        lazy_resolve_root_selection(result, **{query: query})
+        GraphQL::Execution::Flatten.call(query.context)
+      end
+
+      def self.begin_multiplex(_multiplex)
+      end
+
+      def self.begin_query(query, _multiplex)
+        ExecutionFunctions.resolve_root_selection(query)
+      end
+
+      def self.finish_multiplex(results, multiplex)
+        ExecutionFunctions.lazy_resolve_root_selection(results, multiplex: multiplex)
+      end
+
+      def self.finish_query(query, _multiplex)
+        {
+          "data" => Execution::Flatten.call(query.context)
+        }
+      end
+
+      # @api private
+      module ExecutionFunctions
+        module_function
+
+        def resolve_root_selection(query)
+          query.trace("execute_query", query: query) do
+            operation = query.selected_operation
+            op_type = operation.operation_type
+            root_type = query.root_type_for_operation(op_type)
+            if query.context[:__root_unauthorized]
+              # This was set by member/instrumentation.rb so that we wouldn't continue.
+            else
+              resolve_selection(
+                query.root_value,
+                root_type,
+                query.context,
+                mutation: query.mutation?
+              )
+            end
+          end
+        end
+
+        def lazy_resolve_root_selection(result, query: nil, multiplex: nil)
+          if query.nil? && multiplex.queries.length == 1
+            query = multiplex.queries[0]
+          end
+
+          tracer = (query || multiplex)
+          tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
+            GraphQL::Execution::Lazy.resolve(result)
+          end
+        end
+
+        def resolve_selection(object, current_type, current_ctx, mutation: false )
+          # Assign this _before_ resolving the children
+          # so that when a child propagates null, the selection result is
+          # ready for it.
+          current_ctx.value = {}
+
+          selections_on_type = current_ctx.irep_node.typed_children[current_type]
+
+          selections_on_type.each do |name, child_irep_node|
+            field_ctx = current_ctx.spawn_child(
+              key: name,
+              object: object,
+              irep_node: child_irep_node,
+            )
+
+            field_result = resolve_field(
+              object,
+              field_ctx
+            )
+
+            if field_result.is_a?(Skip)
+              next
+            end
+
+            if mutation
+              GraphQL::Execution::Lazy.resolve(field_ctx)
+            end
+
+
+            # If the last subselection caused a null to propagate to _this_ selection,
+            # then we may as well quit executing fields because they
+            # won't be in the response
+            if current_ctx.invalid_null?
+              break
+            else
+              current_ctx.value[name] = field_ctx
+            end
+          end
+
+          current_ctx.value
+        end
+
+        def resolve_field(object, field_ctx)
+          query = field_ctx.query
+          irep_node = field_ctx.irep_node
+          parent_type = irep_node.owner_type
+          field = field_ctx.field
+
+          raw_value = begin
+            begin
+              arguments = query.arguments_for(irep_node, field)
+              field_ctx.trace("execute_field", { context: field_ctx }) do
+                field_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
+              end
+            rescue GraphQL::UnauthorizedFieldError => err
+              err.field ||= field
+              field_ctx.schema.unauthorized_field(err)
+            rescue GraphQL::UnauthorizedError => err
+              field_ctx.schema.unauthorized_object(err)
+            end
+          rescue GraphQL::ExecutionError => err
+            err
+          end
+
+          if field_ctx.schema.lazy?(raw_value)
+            field_ctx.value = Execution::Lazy.new {
+              inner_value = field_ctx.trace("execute_field_lazy", {context: field_ctx}) {
+                begin
+                  begin
+                    field_ctx.field.lazy_resolve(raw_value, arguments, field_ctx)
+                  rescue GraphQL::UnauthorizedError => err
+                    field_ctx.schema.unauthorized_object(err)
+                  end
+                rescue GraphQL::ExecutionError => err
+                  err
+                end
+              }
+              continue_or_wait(inner_value, field_ctx.type, field_ctx)
+            }
+          else
+            continue_or_wait(raw_value, field_ctx.type, field_ctx)
+          end
+        end
+
+        # If the returned object is lazy (unfinished),
+        # assign the lazy object to `.value=` so we can resolve it later.
+        # When we resolve it later, reassign it to `.value=` so that
+        # the finished value replaces the unfinished one.
+        #
+        # If the returned object is finished, continue to coerce
+        # and resolve child fields
+        def continue_or_wait(raw_value, field_type, field_ctx)
+          if field_ctx.schema.lazy?(raw_value)
+            field_ctx.value = Execution::Lazy.new {
+              inner_value = begin
+                  begin
+                    field_ctx.schema.sync_lazy(raw_value)
+                  rescue GraphQL::UnauthorizedError => err
+                    field_ctx.schema.unauthorized_object(err)
+                  end
+                rescue GraphQL::ExecutionError => err
+                  err
+                end
+
+              field_ctx.value = continue_or_wait(inner_value, field_type, field_ctx)
+            }
+          else
+            field_ctx.value = continue_resolve_field(raw_value, field_type, field_ctx)
+          end
+        end
+
+        def continue_resolve_field(raw_value, field_type, field_ctx)
+          if field_ctx.parent.invalid_null?
+            return nil
+          end
+          query = field_ctx.query
+
+          case raw_value
+          when GraphQL::ExecutionError
+            raw_value.ast_node ||= field_ctx.ast_node
+            raw_value.path = field_ctx.path
+            query.context.errors.push(raw_value)
+          when Array
+            if field_type.non_null?
+              # List type errors are handled above, this is for the case of fields returning an array of errors
+              list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
+              if list_errors.any?
+                list_errors.each do |error, index|
+                  error.ast_node = field_ctx.ast_node
+                  error.path = field_ctx.path + (field_ctx.type.list? ? [index] : [])
+                  query.context.errors.push(error)
+                end
+              end
+            end
+          end
+
+          resolve_value(
+            raw_value,
+            field_type,
+            field_ctx,
+          )
+        end
+
+        def resolve_value(value, field_type, field_ctx)
+          field_defn = field_ctx.field
+
+          if value.nil?
+            if field_type.kind.non_null?
+              parent_type = field_ctx.irep_node.owner_type
+              type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
+              field_ctx.schema.type_error(type_error, field_ctx)
+              PROPAGATE_NULL
+            else
+              nil
+            end
+          elsif value.is_a?(GraphQL::ExecutionError)
+            if field_type.kind.non_null?
+              PROPAGATE_NULL
+            else
+              nil
+            end
+          elsif value.is_a?(Array) && value.any? && value.all? {|v| v.is_a?(GraphQL::ExecutionError)}
+            if field_type.kind.non_null?
+              PROPAGATE_NULL
+            else
+              nil
+            end
+          elsif value.is_a?(Skip)
+            field_ctx.value = value
+          else
+            case field_type.kind
+            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
+              field_type.coerce_result(value, field_ctx)
+            when GraphQL::TypeKinds::LIST
+              inner_type = field_type.of_type
+              i = 0
+              result = []
+              field_ctx.value = result
+
+              value.each do |inner_value|
+                inner_ctx = field_ctx.spawn_child(
+                  key: i,
+                  object: inner_value,
+                  irep_node: field_ctx.irep_node,
+                )
+
+                inner_result = continue_or_wait(
+                  inner_value,
+                  inner_type,
+                  inner_ctx,
+                )
+
+                return PROPAGATE_NULL if inner_result == PROPAGATE_NULL
+
+                result << inner_ctx
+                i += 1
+              end
+
+              result
+            when GraphQL::TypeKinds::NON_NULL
+              inner_type = field_type.of_type
+              resolve_value(
+                value,
+                inner_type,
+                field_ctx,
+              )
+            when GraphQL::TypeKinds::OBJECT
+              resolve_selection(
+                value,
+                field_type,
+                field_ctx
+              )
+            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
+              query = field_ctx.query
+              resolved_type_or_lazy = field_type.resolve_type(value, field_ctx)
+              query.schema.after_lazy(resolved_type_or_lazy) do |resolved_type|
+                possible_types = query.possible_types(field_type)
+
+                if !possible_types.include?(resolved_type)
+                  parent_type = field_ctx.irep_node.owner_type
+                  type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                  field_ctx.schema.type_error(type_error, field_ctx)
+                  PROPAGATE_NULL
+                else
+                  resolve_value(
+                    value,
+                    resolved_type,
+                    field_ctx,
+                  )
+                end
+              end
+            else
+              raise("Unknown type kind: #{field_type.kind}")
+            end
+          end
+        end
+      end
+
+      include ExecutionFunctions
+
+      # A `.call`-able suitable to be the last step in a middleware chain
+      module FieldResolveStep
+        # Execute the field's resolve method
+        def self.call(_parent_type, parent_object, field_definition, field_args, context, _next = nil)
+          field_definition.resolve(parent_object, field_args, context)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/flatten.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # Starting from a root context,
+    # create a hash out of the context tree.
+    # @api private
+    module Flatten
+      def self.call(ctx)
+        flatten(ctx)
+      end
+
+      class << self
+        private
+
+        def flatten(obj)
+          case obj
+          when Hash
+            flattened = {}
+            obj.each do |key, val|
+              flattened[key] = flatten(val)
+            end
+            flattened
+          when Array
+            obj.map { |v| flatten(v) }
+          when Query::Context::SharedMethods
+            if obj.invalid_null?
+              nil
+            elsif obj.skipped? && obj.value.empty?
+              nil
+            else
+              flatten(obj.value)
+            end
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end