graphql 1.13.12 → 2.0.21

data/lib/graphql/directive.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # Directives are server-defined hooks for modifying execution.
-  #
-  # Two directives are included out-of-the-box:
-  # - `@skip(if: ...)` Skips the tagged field if the value of `if` is true
-  # - `@include(if: ...)` Includes the tagged field _only_ if `if` is true
-  #
-  class Directive
-    include GraphQL::Define::InstanceDefinable
-    deprecated_accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
-
-    attr_accessor :locations, :arguments, :name, :description, :arguments_class
-    attr_accessor :ast_node
-    # @api private
-    attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :graphql_name, :name, :description, :default_directive?)
-
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_name :name
-
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
-
-    LOCATIONS = [
-      QUERY =                  :QUERY,
-      MUTATION =               :MUTATION,
-      SUBSCRIPTION =           :SUBSCRIPTION,
-      FIELD =                  :FIELD,
-      FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-      FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-      INLINE_FRAGMENT =        :INLINE_FRAGMENT,
-      SCHEMA =                 :SCHEMA,
-      SCALAR =                 :SCALAR,
-      OBJECT =                 :OBJECT,
-      FIELD_DEFINITION =       :FIELD_DEFINITION,
-      ARGUMENT_DEFINITION =    :ARGUMENT_DEFINITION,
-      INTERFACE =              :INTERFACE,
-      UNION =                  :UNION,
-      ENUM =                   :ENUM,
-      ENUM_VALUE =             :ENUM_VALUE,
-      INPUT_OBJECT =           :INPUT_OBJECT,
-      INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-    ]
-
-    LOCATION_DESCRIPTIONS = {
-      QUERY:                    'Location adjacent to a query operation.',
-      MUTATION:                 'Location adjacent to a mutation operation.',
-      SUBSCRIPTION:             'Location adjacent to a subscription operation.',
-      FIELD:                    'Location adjacent to a field.',
-      FRAGMENT_DEFINITION:      'Location adjacent to a fragment definition.',
-      FRAGMENT_SPREAD:          'Location adjacent to a fragment spread.',
-      INLINE_FRAGMENT:          'Location adjacent to an inline fragment.',
-      SCHEMA:                   'Location adjacent to a schema definition.',
-      SCALAR:                   'Location adjacent to a scalar definition.',
-      OBJECT:                   'Location adjacent to an object type definition.',
-      FIELD_DEFINITION:         'Location adjacent to a field definition.',
-      ARGUMENT_DEFINITION:      'Location adjacent to an argument definition.',
-      INTERFACE:                'Location adjacent to an interface definition.',
-      UNION:                    'Location adjacent to a union definition.',
-      ENUM:                     'Location adjacent to an enum definition.',
-      ENUM_VALUE:               'Location adjacent to an enum value definition.',
-      INPUT_OBJECT:             'Location adjacent to an input object type definition.',
-      INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
-    }
-
-    def initialize
-      @arguments = {}
-      @default_directive = false
-    end
-
-    def to_s
-      "<GraphQL::Directive #{name}>"
-    end
-
-    def on_field?
-      locations.include?(FIELD)
-    end
-
-    def on_fragment?
-      locations.include?(FRAGMENT_SPREAD) && locations.include?(INLINE_FRAGMENT)
-    end
-
-    def on_operation?
-      locations.include?(QUERY) && locations.include?(MUTATION) && locations.include?(SUBSCRIPTION)
-    end
-
-    # @return [Boolean] Is this directive supplied by default? (eg `@skip`)
-    def default_directive?
-      @default_directive
-    end
-
-    def inspect
-      "#<GraphQL::Directive #{name}>"
-    end
-
-    def type_class
-      metadata[:type_class]
-    end
-
-    def get_argument(argument_name)
-      arguments[argument_name]
-    end
-  end
-end

data/lib/graphql/enum_type.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class EnumType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_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]
-      deprecated_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/execute.rb

@@ -1,333 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

data/lib/graphql/execution/instrumentation.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    module Instrumentation
-      # This function implements the instrumentation policy:
-      #
-      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
-      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
-      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
-      #
-      # When errors are raised from `after_` hooks:
-      #   - Subsequent `after_` hooks _are_ called
-      #   - The first raised error is captured; later errors are ignored
-      #   - If an error was capture, it's re-raised after all hooks are finished
-      #
-      # Partial runs of instrumentation are possible:
-      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
-      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
-      def self.apply_instrumenters(multiplex)
-        schema = multiplex.schema
-        queries = multiplex.queries
-        query_instrumenters = schema.instrumenters[:query]
-        multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-        # First, run multiplex instrumentation, then query instrumentation for each query
-        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-          each_query_call_hooks(query_instrumenters, queries) do
-            # Let them be executed
-            yield
-          end
-        end
-      end
-
-      class << self
-        private
-        # Call the before_ hooks of each query,
-        # Then yield if no errors.
-        # `call_hooks` takes care of appropriate cleanup.
-        def each_query_call_hooks(instrumenters, queries, i = 0)
-          if i >= queries.length
-            yield
-          else
-            query = queries[i]
-            call_hooks(instrumenters, query, :before_query, :after_query) {
-              each_query_call_hooks(instrumenters, queries, i + 1) {
-                yield
-              }
-            }
-          end
-        end
-
-        # Call each before hook, and if they all succeed, yield.
-        # If they don't all succeed, call after_ for each one that succeeded.
-        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
-          begin
-            successful = []
-            instrumenters.each do |instrumenter|
-              instrumenter.public_send(before_hook_name, object)
-              successful << instrumenter
-            end
-
-            # if any before hooks raise an exception, quit calling before hooks,
-            # but call the after hooks on anything that succeeded but also
-            # raise the exception that came from the before hook.
-          rescue GraphQL::ExecutionError => err
-            object.context.errors << err
-          rescue => e
-            raise call_after_hooks(successful, object, after_hook_name, e)
-          end
-
-          begin
-            yield # Call the user code
-          ensure
-            ex = call_after_hooks(successful, object, after_hook_name, nil)
-            raise ex if ex
-          end
-        end
-
-        def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse_each do |instrumenter|
-            begin
-              instrumenter.public_send(after_hook_name, object)
-            rescue => e
-              ex = e
-            end
-          end
-          ex
-        end
-      end
-    end
-  end
-end