graphql 0.16.0 → 2.0.15

data/lib/graphql/query/literal_input.rb

@@ -1,90 +0,0 @@
-module GraphQL
-  class Query
-    # Turn query string values into something useful for query execution
-    class LiteralInput
-      def self.coerce(type, value, variables)
-        if value.is_a?(Language::Nodes::VariableIdentifier)
-          variables[value.name]
-        elsif value.nil?
-          nil
-        else
-          LiteralKindCoercers::STRATEGIES.fetch(type.kind).coerce(value, type, variables)
-        end
-      end
-
-      def self.from_arguments(ast_arguments, argument_defns, variables)
-        values_hash = {}
-        argument_defns.each do |arg_name, arg_defn|
-          ast_arg = ast_arguments.find { |ast_arg| ast_arg.name == arg_name }
-          arg_value = nil
-          if ast_arg
-            arg_value = coerce(arg_defn.type, ast_arg.value, variables)
-          end
-          if arg_value.nil?
-            arg_value = arg_defn.type.coerce_input(arg_defn.default_value)
-          end
-          values_hash[arg_name] = arg_value
-        end
-        GraphQL::Query::Arguments.new(values_hash)
-      end
-
-      module LiteralKindCoercers
-        module NonNullLiteral
-          def self.coerce(value, type, variables)
-            LiteralInput.coerce(type.of_type, value, variables)
-          end
-        end
-
-        module ListLiteral
-          def self.coerce(value, type, variables)
-            if value.is_a?(Array)
-              value.map{ |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
-            else
-              [LiteralInput.coerce(type.of_type, value, variables)]
-            end
-          end
-        end
-
-        module InputObjectLiteral
-          def self.coerce(value, type, variables)
-            hash = {}
-            value.arguments.each do |arg|
-              field_type = type.input_fields[arg.name].type
-              hash[arg.name] = LiteralInput.coerce(field_type, arg.value, variables)
-            end
-            type.input_fields.each do |arg_name, arg_defn|
-              if hash[arg_name].nil?
-                value = LiteralInput.coerce(arg_defn.type, arg_defn.default_value, variables)
-                if !value.nil?
-                  hash[arg_name] = value
-                end
-              end
-            end
-            Arguments.new(hash)
-          end
-        end
-
-        module EnumLiteral
-          def self.coerce(value, type, variables)
-            type.coerce_input(value.name)
-          end
-        end
-
-        module ScalarLiteral
-          def self.coerce(value, type, variables)
-            type.coerce_input(value)
-          end
-        end
-
-        STRATEGIES = {
-          TypeKinds::NON_NULL =>     NonNullLiteral,
-          TypeKinds::LIST =>         ListLiteral,
-          TypeKinds::INPUT_OBJECT => InputObjectLiteral,
-          TypeKinds::ENUM =>         EnumLiteral,
-          TypeKinds::SCALAR =>       ScalarLiteral,
-        }
-      end
-      private_constant :LiteralKindCoercers
-    end
-  end
-end

data/lib/graphql/query/serial_execution/execution_context.rb

@@ -1,31 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class ExecutionContext
-        attr_reader :query, :schema, :strategy
-
-        def initialize(query, strategy)
-          @query = query
-          @schema = query.schema
-          @strategy = strategy
-        end
-
-        def get_type(type)
-          @schema.types[type]
-        end
-
-        def get_fragment(name)
-          @query.fragments[name]
-        end
-
-        def get_field(type, name)
-          @schema.get_field(type, name)
-        end
-
-        def add_error(err)
-          @query.context.errors << err
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -1,82 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class FieldResolution
-        attr_reader :irep_node, :parent_type, :target, :execution_context, :field, :arguments
-
-        def initialize(irep_node, parent_type, target, execution_context)
-          @irep_node = irep_node
-          @parent_type = parent_type
-          @target = target
-          @execution_context = execution_context
-          @field = execution_context.get_field(parent_type, irep_node.definition.name)
-          if @field.nil?
-            raise("No field found on #{parent_type.name} '#{parent_type}' for '#{ast_node.name}'")
-          end
-          @arguments = execution_context.query.arguments_for(irep_node)
-        end
-
-        def result
-          result_name = irep_node.name
-          begin
-            raw_value = get_raw_value
-            { result_name => get_finished_value(raw_value) }
-          rescue GraphQL::InvalidNullError => err
-            if field.type.kind.non_null?
-              raise(err)
-            else
-              err.parent_error? || execution_context.add_error(err)
-              {result_name => nil}
-            end
-          end
-        end
-
-        private
-
-        # After getting the value from the field's resolve method,
-        # continue by "finishing" the value, eg. executing sub-fields or coercing values
-        def get_finished_value(raw_value)
-          if raw_value.is_a?(GraphQL::ExecutionError)
-            raw_value.ast_node = irep_node.ast_node
-            execution_context.add_error(raw_value)
-          end
-
-          strategy_class = GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(field.type.kind)
-          result_strategy = strategy_class.new(raw_value, field.type, target, parent_type, irep_node, execution_context)
-          result_strategy.result
-        end
-
-
-        # Get the result of:
-        # - Any middleware on this schema
-        # - The field's resolve method
-        # If the middleware chain returns a GraphQL::ExecutionError, its message
-        # is added to the "errors" key.
-        def get_raw_value
-          steps = execution_context.query.schema.middleware + [get_middleware_proc_from_field_resolve]
-          chain = GraphQL::Schema::MiddlewareChain.new(
-            steps: steps,
-            arguments: [parent_type, target, field, arguments, execution_context.query.context]
-          )
-          chain.call
-        rescue GraphQL::ExecutionError => err
-          err
-        end
-
-
-        # Execute the field's resolve method
-        # @return [Proc] suitable to be the last step in a middleware chain
-        def get_middleware_proc_from_field_resolve
-          -> (_parent_type, parent_object, field_definition, field_args, context, _next) {
-            context.ast_node = irep_node.ast_node
-            context.irep_node = irep_node
-            value = field_definition.resolve(parent_object, field_args, context)
-            context.ast_node = nil
-            context.irep_node = nil
-            value
-          }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/operation_resolution.rb

@@ -1,27 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class OperationResolution
-        attr_reader :target, :execution_context, :irep_node
-
-        def initialize(irep_node, target, execution_context)
-          @target = target
-          @irep_node = irep_node
-          @execution_context = execution_context
-        end
-
-        def result
-          execution_context.strategy.selection_resolution.new(
-            execution_context.query.root_value,
-            target,
-            irep_node,
-            execution_context
-          ).result
-        rescue GraphQL::InvalidNullError => err
-          err.parent_error? || execution_context.add_error(err)
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -1,42 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      class SelectionResolution
-        attr_reader :target, :type, :irep_node, :execution_context
-
-        def initialize(target, type, irep_node, execution_context)
-          @target = target
-          @type = type
-          @irep_node = irep_node
-          @execution_context = execution_context
-        end
-
-        def result
-          irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if included_by_directives?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
-              field_result = execution_context.strategy.field_resolution.new(
-                irep_node,
-                type,
-                target,
-                execution_context
-              ).result
-              memo.merge!(field_result)
-            end
-          end
-        end
-
-        private
-
-        def included_by_directives?(irep_node, query)
-          GraphQL::Query::DirectiveResolution.include_node?(irep_node, query)
-        end
-
-        def applies_to_type?(irep_node, type, target)
-          irep_node.on_types.any? { |child_type|
-            GraphQL::Query::TypeResolver.new(target, child_type, type, execution_context.query.context).type
-          }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -1,107 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      module ValueResolution
-        def self.get_strategy_for_kind(kind)
-          TYPE_KIND_STRATEGIES[kind] || raise("No value resolution strategy for #{kind}!")
-        end
-
-        class BaseResolution
-          attr_reader :value, :field_type, :target, :parent_type,
-            :irep_node, :execution_context
-          def initialize(value, field_type, target, parent_type, irep_node, execution_context)
-            @value = value
-            @field_type = field_type
-            @target = target
-            @parent_type = parent_type
-            @irep_node = irep_node
-            @execution_context = execution_context
-          end
-
-          def result
-            return nil if value.nil? || value.is_a?(GraphQL::ExecutionError)
-            non_null_result
-          end
-
-          def non_null_result
-            raise NotImplementedError, "Should return a value based on initialization params"
-          end
-
-          def get_strategy_for_kind(*args)
-            GraphQL::Query::SerialExecution::ValueResolution.get_strategy_for_kind(*args)
-          end
-        end
-
-        class ScalarResolution < BaseResolution
-          # Apply the scalar's defined `coerce_result` method to the value
-          def non_null_result
-            field_type.coerce_result(value)
-          end
-        end
-
-        class ListResolution < BaseResolution
-          # For each item in the list,
-          # Resolve it with the "wrapped" type of this list
-          def non_null_result
-            wrapped_type = field_type.of_type
-            strategy_class = get_strategy_for_kind(wrapped_type.kind)
-            value.map do |item|
-              inner_strategy = strategy_class.new(item, wrapped_type, target, parent_type, irep_node, execution_context)
-              inner_strategy.result
-            end
-          end
-        end
-
-        class HasPossibleTypeResolution < BaseResolution
-          def non_null_result
-            resolved_type = field_type.resolve_type(value, execution_context)
-
-            unless resolved_type.is_a?(GraphQL::ObjectType)
-              raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition.name, field_type, parent_type)
-            end
-
-            strategy_class = get_strategy_for_kind(resolved_type.kind)
-            inner_strategy = strategy_class.new(value, resolved_type, target, parent_type, irep_node, execution_context)
-            inner_strategy.result
-          end
-        end
-
-        class ObjectResolution < BaseResolution
-          # Resolve the selections on this object
-          def non_null_result
-            execution_context.strategy.selection_resolution.new(
-              value,
-              field_type,
-              irep_node,
-              execution_context
-            ).result
-          end
-        end
-
-        class NonNullResolution < BaseResolution
-          # Get the "wrapped" type and resolve the value according to that type
-          def result
-            if value.nil? || value.is_a?(GraphQL::ExecutionError)
-              raise GraphQL::InvalidNullError.new(irep_node.definition.name, value)
-            else
-              wrapped_type = field_type.of_type
-              strategy_class = get_strategy_for_kind(wrapped_type.kind)
-              inner_strategy = strategy_class.new(value, wrapped_type, target, parent_type, irep_node, execution_context)
-              inner_strategy.result
-            end
-          end
-        end
-
-        TYPE_KIND_STRATEGIES = {
-          GraphQL::TypeKinds::SCALAR =>     ScalarResolution,
-          GraphQL::TypeKinds::LIST =>       ListResolution,
-          GraphQL::TypeKinds::OBJECT =>     ObjectResolution,
-          GraphQL::TypeKinds::ENUM =>       ScalarResolution,
-          GraphQL::TypeKinds::NON_NULL =>   NonNullResolution,
-          GraphQL::TypeKinds::INTERFACE =>  HasPossibleTypeResolution,
-          GraphQL::TypeKinds::UNION =>      HasPossibleTypeResolution,
-        }
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution.rb

@@ -1,41 +0,0 @@
-module GraphQL
-  class Query
-    class SerialExecution
-      # This is the only required method for an Execution strategy.
-      # You could create a custom execution strategy and configure your schema to
-      # use that custom strategy instead.
-      #
-      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
-      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
-      # @param query_obj [GraphQL::Query] the query object for this execution
-      # @return [Hash] a spec-compliant GraphQL result, as a hash
-      def execute(ast_operation, root_type, query_object)
-        irep_root = query_object.internal_representation[ast_operation.name]
-
-        operation_resolution.new(
-          irep_root,
-          root_type,
-          ExecutionContext.new(query_object, self)
-        ).result
-      end
-
-      def field_resolution
-        self.class::FieldResolution
-      end
-
-      def operation_resolution
-        self.class::OperationResolution
-      end
-
-      def selection_resolution
-        self.class::SelectionResolution
-      end
-    end
-  end
-end
-
-require "graphql/query/serial_execution/execution_context"
-require "graphql/query/serial_execution/value_resolution"
-require "graphql/query/serial_execution/field_resolution"
-require "graphql/query/serial_execution/operation_resolution"
-require "graphql/query/serial_execution/selection_resolution"

data/lib/graphql/query/type_resolver.rb

@@ -1,25 +0,0 @@
-module GraphQL
-  class Query
-    # Given an object, a type name (from the query) and a type object,
-    # Return the type that should be used for `object`
-    # or Return `nil` if it's a mismatch
-    class TypeResolver
-      attr_reader :type
-      def initialize(target, child_type, parent_type, query_ctx)
-        @type = if child_type.nil?
-          nil
-        elsif parent_type.kind.union?
-          parent_type.resolve_type(target)
-        elsif child_type.kind.union? && child_type.include?(parent_type)
-          parent_type
-        elsif child_type.kind.interface?
-          child_type.resolve_type(target, query_ctx)
-        elsif child_type == parent_type
-          parent_type
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/graphql/scalar_type.rb

@@ -1,53 +0,0 @@
-module GraphQL
-  # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
-  #
-  # @example defining a type for Time
-  #   TimeType = GraphQL::ScalarType.define do
-  #     name "Time"
-  #     description "Time since epoch in seconds"
-  #
-  #     coerce_input ->(value) { Time.at(Float(value)) }
-  #     coerce_result ->(value) { value.to_f }
-  #   end
-  #
-  class ScalarType < GraphQL::BaseType
-    accepts_definitions :coerce, :coerce_input, :coerce_result
-
-    def coerce=(proc)
-      self.coerce_input = proc
-      self.coerce_result = proc
-    end
-
-    def validate_non_null_input(value)
-      result = Query::InputValidationResult.new
-      if coerce_non_null_input(value).nil?
-        result.add_problem("Could not coerce value #{JSON.dump(value)} to #{name}")
-      end
-      result
-    end
-
-    def coerce_non_null_input(value)
-      @coerce_input_proc.call(value)
-    end
-
-    def coerce_input=(proc)
-      if !proc.nil?
-        @coerce_input_proc = proc
-      end
-    end
-
-    def coerce_result(value)
-      @coerce_result_proc.call(value)
-    end
-
-    def coerce_result=(proc)
-      if !proc.nil?
-        @coerce_result_proc = proc
-      end
-    end
-
-    def kind
-      GraphQL::TypeKinds::SCALAR
-    end
-  end
-end

data/lib/graphql/schema/catchall_middleware.rb

@@ -1,34 +0,0 @@
-module GraphQL
-  class Schema
-    # In early GraphQL versions, errors would be "automatically"
-    # rescued and replaced with `"Internal error"`. That behavior
-    # was undesirable but this middleware is offered for people who
-    # want to preserve it.
-    #
-    # It has a couple of differences from the previous behavior:
-    #
-    # - Other parts of the query _will_ be run (previously,
-    #   execution would stop when the error was raised and the result
-    #   would have no `"data"` key at all)
-    # - The entry in {Query::Context#errors} is a {GraphQL::ExecutionError}, _not_
-    #   the originally-raised error.
-    # - The entry in the `"errors"` key includes the location of the field
-    #   which raised the errors.
-    #
-    # @example Use CatchallMiddleware with your schema
-    #     # All errors will be suppressed and replaced with "Internal error" messages
-    #     MySchema.middleware << GraphQL::Schema::CatchallMiddleware
-    #
-    module CatchallMiddleware
-      MESSAGE = "Internal error"
-
-      # Rescue any error and replace it with a {GraphQL::ExecutionError}
-      # whose message is {MESSAGE}
-      def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
-        next_middleware.call
-      rescue StandardError => err
-        GraphQL::ExecutionError.new(MESSAGE)
-      end
-    end
-  end
-end

data/lib/graphql/schema/middleware_chain.rb

@@ -1,28 +0,0 @@
-module GraphQL
-  class Schema
-    # Given {steps} and {arguments}, call steps in order, passing `(*arguments, next_step)`.
-    #
-    # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
-    class MiddlewareChain
-      # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
-      attr_reader :steps
-
-      # @return [Array] Arguments passed to steps (followed by `next_middleware`)
-      attr_reader :arguments
-
-      def initialize(steps:, arguments:)
-        # We're gonna destroy this array, so copy it:
-        @steps = steps.dup
-        @arguments = arguments
-      end
-
-      # Run the next step in the chain, passing in arguments and handle to the next step
-      def call(next_arguments = @arguments)
-        @arguments = next_arguments
-        next_step = steps.shift
-        next_middleware = self
-        next_step.call(*arguments, next_middleware)
-      end
-    end
-  end
-end

data/lib/graphql/schema/possible_types.rb

@@ -1,34 +0,0 @@
-module GraphQL
-  class Schema
-    # Find the members of a union or interface within a given schema.
-    #
-    # (Although its members never change, unions are handled this way to simplify execution code.)
-    #
-    # Internally, the calculation is cached. It's assumed that schema members _don't_ change after creating the schema!
-    #
-    # @example Get an interface's possible types
-    #   possible_types = GraphQL::Schema::PossibleTypes(MySchema)
-    #   possible_types.possible_types(MyInterface)
-    #   # => [MyObjectType, MyOtherObjectType]
-    class PossibleTypes
-      def initialize(schema)
-        @object_types = schema.types.values.select { |type| type.kind.object? }
-
-        @storage = Hash.new do |hash, key|
-          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
-        end
-      end
-
-      def possible_types(type_defn)
-        case type_defn
-        when GraphQL::UnionType
-          type_defn.possible_types
-        when GraphQL::InterfaceType
-          @storage[type_defn]
-        else
-          raise "#{type_defn} doesn't have possible types"
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/reduce_types.rb

@@ -1,68 +0,0 @@
-module GraphQL
-  class Schema
-    module ReduceTypes
-      # @param types [Array<GraphQL::BaseType>] members of a schema to crawl for all member types
-      # @return [GraphQL::Schema::TypeMap] `{name => Type}` pairs derived from `types`
-      def self.reduce(types)
-        type_map = GraphQL::Schema::TypeMap.new
-        types.each do |type|
-          reduce_type(type, type_map, type.name)
-        end
-        type_map
-      end
-
-      private
-
-      # Based on `type`, add members to `type_hash`.
-      # If `type` has already been visited, just return the `type_hash` as-is
-      def self.reduce_type(type, type_hash, context_description)
-        if !type.is_a?(GraphQL::BaseType)
-          message = "#{context_description} has an invalid type: must be an instance of GraphQL::BaseType, not #{type.class.inspect} (#{type.inspect})"
-          raise GraphQL::Schema::InvalidTypeError.new(message)
-        end
-
-        type = type.unwrap
-
-        # Don't re-visit a type
-        if !type_hash.fetch(type.name, nil).equal?(type)
-          validate_type(type, context_description)
-          type_hash[type.name] = type
-          crawl_type(type, type_hash, context_description)
-        end
-      end
-
-      def self.crawl_type(type, type_hash, context_description)
-        if type.kind.fields?
-          type.all_fields.each do |field|
-            reduce_type(field.type, type_hash, "Field #{type.name}.#{field.name}")
-            field.arguments.each do |name, argument|
-              reduce_type(argument.type, type_hash, "Argument #{name} on #{type.name}.#{field.name}")
-            end
-          end
-        end
-        if type.kind.object?
-          type.interfaces.each do |interface|
-            reduce_type(interface, type_hash, "Interface on #{type.name}")
-          end
-        end
-        if type.kind.union?
-          type.possible_types.each do |possible_type|
-            reduce_type(possible_type, type_hash, "Possible type for #{type.name}")
-          end
-        end
-        if type.kind.input_object?
-          type.arguments.each do |argument_name, argument|
-            reduce_type(argument.type, type_hash, "Input field #{type.name}.#{argument_name}")
-          end
-        end
-      end
-
-      def self.validate_type(type, context_description)
-        error_message = GraphQL::Schema::Validation.validate(type)
-        if error_message
-          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
-        end
-      end
-    end
-  end
-end