graphql 1.9.0 → 2.1.1

data/lib/graphql/directive.rb

@@ -1,104 +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
-    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,
-    ]
-
-    DEFAULT_DEPRECATION_REASON = 'No longer supported'
-    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
-  end
-end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"

data/lib/graphql/enum_type.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # Represents a collection of related values.
-  # By convention, enum names are `SCREAMING_CASE_NAMES`,
-  # but other identifiers are supported too.
-  #
-  # You can use as return types _or_ as inputs.
-  #
-  # By default, enums are passed to `resolve` functions as
-  # the strings that identify them, but you can provide a
-  # custom Ruby value with the `value:` keyword.
-  #
-  # @example An enum of programming languages
-  #   LanguageEnum = GraphQL::EnumType.define do
-  #     name "Language"
-  #     description "Programming language for Web projects"
-  #     value("PYTHON", "A dynamic, function-oriented language")
-  #     value("RUBY", "A very dynamic language aimed at programmer happiness")
-  #     value("JAVASCRIPT", "Accidental lingua franca of the web")
-  #   end
-  #
-  # @example Using an enum as a return type
-  #    field :favoriteLanguage, LanguageEnum, "This person's favorite coding language"
-  #    # ...
-  #    # In a query:
-  #    Schema.execute("{ coder(id: 1) { favoriteLanguage } }")
-  #    # { "data" => { "coder" => { "favoriteLanguage" => "RUBY" } } }
-  #
-  # @example Defining an enum input
-  #    field :coders, types[CoderType] do
-  #      argument :knowing, types[LanguageEnum]
-  #      resolve ->(obj, args, ctx) {
-  #        Coder.where(language: args[:knowing])
-  #      }
-  #    end
-  #
-  # @example Using an enum as input
-  #   {
-  #     # find coders who know Python and Ruby
-  #     coders(knowing: [PYTHON, RUBY]) {
-  #       name
-  #       hourlyRate
-  #     }
-  #   }
-  #
-  # @example Enum whose values are different in Ruby-land
-  #   GraphQL::EnumType.define do
-  #     # ...
-  #     # use the `value:` keyword:
-  #     value("RUBY", "Lisp? Smalltalk?", value: :rb)
-  #   end
-  #
-  #   # Now, resolve functions will receive `:rb` instead of `"RUBY"`
-  #   field :favoriteLanguage, LanguageEnum
-  #   resolve ->(obj, args, ctx) {
-  #     args[:favoriteLanguage] # => :rb
-  #   }
-  #
-  # @example Enum whose values are different in ActiveRecord-land
-  #   class Language < ActiveRecord::Base
-  #     enum language: {
-  #       rb: 0
-  #     }
-  #   end
-  #
-  #   # Now enum type should be defined as
-  #   GraphQL::EnumType.define do
-  #     # ...
-  #     # use the `value:` keyword:
-  #     value("RUBY", "Lisp? Smalltalk?", value: 'rb')
-  #   end
-  #
-
-  class EnumType < GraphQL::BaseType
-    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
-      @values_by_name
-    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
-    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,319 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    # A valid execution strategy
-    # @api private
-    class Execute
-
-      # @api private
-      class Skip; 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 execute(ast_operation, root_type, query)
-        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)
-            resolve_selection(
-              query.root_value,
-              root_type,
-              query.context,
-              mutation: query.mutation?
-            )
-          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::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.list?
-              # 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