graphql 0.16.0 → 2.0.15

data/lib/graphql/schema/rescue_middleware.rb

@@ -1,53 +0,0 @@
-module GraphQL
-  class Schema
-    # - Store a table of errors & handlers
-    # - Rescue errors in a middleware chain, then check for a handler
-    # - If a handler is found, use it & return a {GraphQL::ExecutionError}
-    # - If no handler is found, re-raise the error
-    class RescueMiddleware
-      # @return [Hash] `{class => proc}` pairs for handling errors
-      attr_reader :rescue_table
-      def initialize
-        @rescue_table = {}
-      end
-
-      # @example Rescue from not-found by telling the user
-      #   MySchema.rescue_from(ActiveRecord::RecordNotFound) { "An item could not be found" }
-      #
-      # @param [Class] a class of error to rescue from
-      # @yield [err] A handler to return a message for this error instance
-      # @yieldparam [Exception] an error that was rescued
-      # @yieldreturn [String] message to put in GraphQL response
-      def rescue_from(error_class, &block)
-        rescue_table[error_class] = block
-      end
-
-      # Remove the handler for `error_class`
-      # @param [Class] the error class whose handler should be removed
-      def remove_handler(error_class)
-        rescue_table.delete(error_class)
-      end
-
-      # Implement the requirement for {GraphQL::Schema::MiddlewareChain}
-      def call(*args, next_middleware)
-        begin
-          next_middleware.call
-        rescue StandardError => err
-          attempt_rescue(err)
-        end
-      end
-
-      private
-
-      def attempt_rescue(err)
-        handler = rescue_table[err.class]
-        if handler
-          message = handler.call(err)
-          GraphQL::ExecutionError.new(message)
-        else
-          raise(err)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/timeout_middleware.rb

@@ -1,67 +0,0 @@
-module GraphQL
-  class Schema
-    # This middleware will stop resolving new fields after `max_seconds` have elapsed.
-    # After the time has passed, any remaining fields will be `nil`, with errors added
-    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
-    # you'll get a partial response.
-    #
-    # You can provide a block which will be called with any timeout errors that occur.
-    #
-    # Note that this will stop a query _in between_ field resolutions, but
-    # it doesn't interrupt long-running `resolve` functions. Be sure to use
-    # timeout options for external connections. For more info, see
-    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
-    #
-    # @example Stop resolving fields after 2 seconds
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2)
-    #
-    # @example Notifying Bugsnag on a timeout
-    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware(max_seconds: 1.5) do |timeout_error, query|
-    #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
-    #   end
-    #
-    class TimeoutMiddleware
-      # This key is used for storing timeout data in the {Query::Context} instance
-      DEFAULT_CONTEXT_KEY = :__timeout_at__
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
-      # @param context_key [Symbol] what key should be used to read and write to the query context
-      def initialize(max_seconds:, context_key: DEFAULT_CONTEXT_KEY, &block)
-        @max_seconds = max_seconds
-        @context_key = context_key
-        @error_handler = block
-      end
-
-      def call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
-        timeout_at = query_context[@context_key] ||= Time.now + @max_seconds
-        if timeout_at < Time.now
-          on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
-        else
-          next_middleware.call
-        end
-      end
-
-      # This is called when a field _would_ be resolved, except that we're over the time limit.
-      # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
-      def on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
-        err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
-        if @error_handler
-          @error_handler.call(err, query_context.query)
-        end
-        err
-      end
-    end
-
-    # This error is raised when a query exceeds `max_seconds`.
-    # Since it's a child of {GraphQL::ExecutionError},
-    # its message will be added to the response's `errors` key.
-    #
-    # To raise an error that will stop query resolution, use a custom block
-    # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
-    # such as `RuntimeError`.
-    class GraphQL::Schema::TimeoutMiddleware::TimeoutError < GraphQL::ExecutionError
-      def initialize(parent_type, field_defn)
-        super("Timeout on #{parent_type.name}.#{field_defn.name}")
-      end
-    end
-  end
-end

data/lib/graphql/schema/type_map.rb

@@ -1,30 +0,0 @@
-module GraphQL
-  class Schema
-    # Stores `{ name => type }` pairs for a given schema.
-    # It behaves like a hash except for a couple things:
-    #  - if you use `[key]` and that key isn't defined, 💥!
-    #  - if you try to define the same key twice, 💥!
-    #
-    # If you want a type, but want to handle the undefined case, use {#fetch}.
-    class TypeMap
-      extend Forwardable
-      def_delegators :@storage, :key?, :keys, :values, :to_h, :fetch
-
-      def initialize
-        @storage = {}
-      end
-
-      def [](key)
-        @storage[key] || raise("No type found for '#{key}'")
-      end
-
-      def []=(key, value)
-        if @storage.key?(key)
-          raise("Duplicate type definition found for name '#{key}'")
-        else
-          @storage[key] = value
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema/validation.rb

@@ -1,164 +0,0 @@
-module GraphQL
-  class Schema
-    # This module provides a function for validating GraphQL types.
-    #
-    # Its {RULES} contain objects that respond to `#call(type)`. Rules are
-    # looked up for given types (by class ancestry), then applied to
-    # the object until an error is returned.
-    class Validation
-      # Lookup the rules for `object` based on its class,
-      # Then returns an error message or `nil`
-      # @param object [Object] something to be validated
-      # @return [String, Nil] error message, if there was one
-      def self.validate(object)
-        rules = RULES.reduce([]) do |memo, (parent_class, validations)|
-          memo + (object.is_a?(parent_class) ? validations : [])
-        end
-        # Stops after the first error
-        rules.reduce(nil) { |memo, rule| memo || rule.call(object) }
-      end
-
-      module Rules
-        # @param property_name [Symbol] The method to validate
-        # @param allowed_classes [Class] Classes which the return value may be an instance of
-        # @return [Proc] A proc which will validate the input by calling `property_name` and asserting it is an instance of one of `allowed_classes`
-        def self.assert_property(property_name, *allowed_classes)
-          allowed_classes_message = allowed_classes.map(&:name).join(" or ")
-          -> (obj) {
-            property_value = obj.public_send(property_name)
-            is_valid_value = allowed_classes.any? { |allowed_class| property_value.is_a?(allowed_class) }
-            is_valid_value ? nil : "#{property_name} must return #{allowed_classes_message}, not #{property_value.class.name} (#{property_value.inspect})"
-          }
-        end
-
-        # @param property_name [Symbol] The method whose return value will be validated
-        # @param from_class [Class] The class for keys in the return value
-        # @param to_class [Class] The class for values in the return value
-        # @return [Proc] A proc to validate that validates the input by calling `property_name` and asserting that the return value is a Hash of `{from_class => to_class}` pairs
-        def self.assert_property_mapping(property_name, from_class, to_class)
-          -> (obj) {
-            property_value = obj.public_send(property_name)
-            error_message = nil
-            if !property_value.is_a?(Hash)
-              "#{property_name} must be a hash of {#{from_class.name} => #{to_class.name}}, not a #{property_value.class.name} (#{property_value.inspect})"
-            else
-              invalid_key, invalid_value = property_value.find { |key, value| !key.is_a?(from_class) || !value.is_a?(to_class) }
-              if invalid_key
-                "#{property_name} must map #{from_class} => #{to_class}, not #{invalid_key.class.name} => #{invalid_value.class.name} (#{invalid_key.inspect} => #{invalid_value.inspect})"
-              else
-                nil # OK
-              end
-            end
-          }
-        end
-
-        # @param property_name [Symbol] The method whose return value will be validated
-        # @param list_member_class [Class] The class which each member of the returned array should be an instance of
-        # @return [Proc] A proc to validate the input by calling `property_name` and asserting that the return is an Array of `list_member_class` instances
-        def self.assert_property_list_of(property_name, list_member_class)
-          -> (obj) {
-            property_value = obj.public_send(property_name)
-            if !property_value.is_a?(Array)
-              "#{property_name} must be an Array of #{list_member_class.name}, not a #{property_value.class.name} (#{property_value.inspect})"
-            else
-              invalid_member = property_value.find { |value| !value.is_a?(list_member_class) }
-              if invalid_member
-                "#{property_name} must contain #{list_member_class.name}, not #{invalid_member.class.name} (#{invalid_member.inspect})"
-              else
-                nil # OK
-              end
-            end
-          }
-        end
-
-        def self.assert_named_items_are_valid(item_name, get_items_proc)
-          -> (type) {
-            items = get_items_proc.call(type)
-            error_message = nil
-            items.each do |item|
-              item_message = GraphQL::Schema::Validation.validate(item)
-              if item_message
-                error_message = "#{item_name} #{item.name.inspect} #{item_message}"
-                break
-              end
-            end
-            error_message
-          }
-        end
-
-
-        FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", -> (type) { type.all_fields })
-
-        HAS_ONE_OR_MORE_POSSIBLE_TYPES = -> (type) {
-          type.possible_types.length >= 1 ? nil : "must have at least one possible type"
-        }
-
-        NAME_IS_STRING = Rules.assert_property(:name, String)
-        DESCRIPTION_IS_STRING_OR_NIL = Rules.assert_property(:description, String, NilClass)
-        ARGUMENTS_ARE_STRING_TO_ARGUMENT = Rules.assert_property_mapping(:arguments, String, GraphQL::Argument)
-        ARGUMENTS_ARE_VALID =  Rules.assert_named_items_are_valid("argument", -> (type) { type.arguments.values })
-
-        DEFAULT_VALUE_IS_VALID_FOR_TYPE = -> (type) {
-          if !type.default_value.nil?
-            coerced_value = type.type.coerce_input(type.default_value)
-            if coerced_value.nil?
-              "default value #{type.default_value.inspect} is not valid for type #{type.type}"
-            end
-          end
-        }
-
-        TYPE_IS_VALID_INPUT_TYPE = -> (type) {
-          outer_type = type.type
-          inner_type = outer_type.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
-
-          case inner_type
-          when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
-            # OK
-          else
-            "type must be a valid input type (Scalar or InputObject), not #{outer_type.class} (#{outer_type})"
-          end
-        }
-      end
-
-      # A mapping of `{Class => [Proc, Proc...]}` pairs.
-      # To validate an instance, find entries where `object.is_a?(key)` is true.
-      # Then apply each rule from the matching values.
-      RULES = {
-        GraphQL::Field => [
-          Rules::NAME_IS_STRING,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-          Rules.assert_property(:deprecation_reason, String, NilClass),
-          Rules.assert_property(:type, GraphQL::BaseType),
-          Rules.assert_property(:property, Symbol, NilClass),
-          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
-          Rules::ARGUMENTS_ARE_VALID,
-        ],
-        GraphQL::Argument => [
-          Rules::NAME_IS_STRING,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-          Rules::TYPE_IS_VALID_INPUT_TYPE,
-          Rules::DEFAULT_VALUE_IS_VALID_FOR_TYPE,
-        ],
-        GraphQL::BaseType => [
-          Rules::NAME_IS_STRING,
-          Rules::DESCRIPTION_IS_STRING_OR_NIL,
-        ],
-        GraphQL::ObjectType => [
-          Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
-          Rules::FIELDS_ARE_VALID,
-        ],
-        GraphQL::InputObjectType => [
-          Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
-          Rules::ARGUMENTS_ARE_VALID,
-        ],
-        GraphQL::UnionType => [
-          Rules.assert_property_list_of(:possible_types, GraphQL::ObjectType),
-          Rules::HAS_ONE_OR_MORE_POSSIBLE_TYPES,
-        ],
-        GraphQL::InterfaceType => [
-          Rules::FIELDS_ARE_VALID,
-        ],
-      }
-    end
-  end
-end

data/lib/graphql/static_validation/arguments_validator.rb

@@ -1,48 +0,0 @@
-module GraphQL
-  module StaticValidation
-    # Implement validate_node
-    class ArgumentsValidator
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        visitor = context.visitor
-        visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
-          if parent.is_a?(GraphQL::Language::Nodes::InputObject)
-            arg_defn = context.argument_definition
-            if arg_defn.nil?
-              return
-            else
-              parent_defn = arg_defn.type.unwrap
-              if parent_defn.is_a?(GraphQL::ScalarType)
-                return
-              end
-            end
-          elsif context.skip_field?(parent.name)
-            return
-          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
-            parent_defn = context.schema.directives[parent.name]
-          else
-            parent_defn = context.field_definition
-          end
-          validate_node(parent, node, parent_defn, context)
-        }
-      end
-
-      private
-
-      def parent_name(parent, type_defn)
-        field_name = if parent.is_a?(GraphQL::Language::Nodes::Field)
-          parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
-          parent.name
-        end
-      end
-
-      def node_type(parent)
-        parent.class.name.split("::").last
-      end
-    end
-  end
-end

data/lib/graphql/static_validation/message.rb

@@ -1,36 +0,0 @@
-module GraphQL
-  module StaticValidation
-    # Generates GraphQL-compliant validation message.
-    # Only supports one "location", too bad :(
-    class Message
-      # Convenience for validators
-      module MessageHelper
-        # Error `message` is located at `node`
-        def message(message, node)
-          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col)
-        end
-      end
-      attr_reader :message, :line, :col
-
-      def initialize(message, line: nil, col: nil)
-        @message = message
-        @line = line
-        @col = col
-      end
-
-      # A hash representation of this Message
-      def to_h
-        {
-          "message" => message,
-          "locations" => locations
-        }
-      end
-
-      private
-
-      def locations
-        @line.nil? && @col.nil? ? [] : [{"line" => @line, "column" => @col}]
-      end
-    end
-  end
-end

data/lib/graphql/string_type.rb

@@ -1,5 +0,0 @@
-GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
-  name "String"
-  coerce_result -> (value) { value.to_s }
-  coerce_input -> (value) { value.is_a?(String) ? value : nil }
-end

data/lib/graphql/union_type.rb

@@ -1,38 +0,0 @@
-module GraphQL
-  # A collection of {ObjectType}s
-  #
-  # @example a union of types
-  #
-  #   PetUnion = GraphQL::UnionType.define do
-  #     name "Pet"
-  #     description "Animals that live in your house"
-  #     possible_types [DogType, CatType, FishType]
-  #   end
-  #
-  class UnionType < GraphQL::BaseType
-    include GraphQL::BaseType::HasPossibleTypes
-    attr_accessor :name, :description
-    accepts_definitions :possible_types, :resolve_type
-
-    def kind
-      GraphQL::TypeKinds::UNION
-    end
-
-    def include?(child_type_defn)
-      possible_types.include?(child_type_defn)
-    end
-
-    def possible_types=(new_possible_types)
-      @clean_possible_types = nil
-      @dirty_possible_types = new_possible_types
-    end
-
-    def possible_types
-      @clean_possible_types ||= begin
-        @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-      rescue
-        @dirty_possible_types
-      end
-    end
-  end
-end

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Analysis do
-  class TypeCollector
-    def initial_value(query)
-      []
-    end
-
-    def call(memo, visit_type, irep_node)
-      if visit_type == :enter
-        memo + [irep_node.return_type]
-      else
-        memo
-      end
-    end
-  end
-
-  describe ".analyze_query" do
-    let(:node_counter) {
-      -> (memo, visit_type, irep_node) {
-        memo ||= Hash.new { |h,k| h[k] = 0 }
-        visit_type == :enter && memo[irep_node.ast_node.class] += 1
-        memo
-      }
-    }
-    let(:type_collector) { TypeCollector.new }
-    let(:analyzers) { [type_collector, node_counter] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    it "calls the defined analyzers" do
-      collected_types, node_counts = reduce_result
-      expected_visited_types = [QueryType, CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
-      assert_equal expected_visited_types, collected_types
-      expected_node_counts = {
-        GraphQL::Language::Nodes::OperationDefinition => 1,
-        GraphQL::Language::Nodes::Field => 3,
-      }
-      assert_equal expected_node_counts, node_counts
-    end
-  end
-end

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -1,62 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Analysis::MaxQueryComplexity do
-  before do
-    @prev_max_complexity = DummySchema.max_complexity
-  end
-
-  after do
-    DummySchema.max_complexity = @prev_max_complexity
-  end
-
-
-  let(:result) { DummySchema.execute(query_string) }
-  let(:query_string) {%|
-    {
-      a: cheese(id: 1) { id }
-      b: cheese(id: 1) { id }
-      c: cheese(id: 1) { id }
-      d: cheese(id: 1) { id }
-      e: cheese(id: 1) { id }
-    }
-  |}
-
-  describe "when a query goes over max complexity" do
-    before do
-      DummySchema.max_complexity = 9
-    end
-
-    it "returns an error" do
-      assert_equal "Query has complexity of 10, which exceeds max complexity of 9", result["errors"][0]["message"]
-    end
-  end
-
-  describe "when there is no max complexity" do
-    before do
-      DummySchema.max_complexity = nil
-    end
-    it "doesn't error" do
-      assert_equal nil, result["errors"]
-    end
-  end
-
-  describe "when the query is less than the max complexity" do
-    before do
-      DummySchema.max_complexity = 99
-    end
-    it "doesn't error" do
-      assert_equal nil, result["errors"]
-    end
-  end
-
-  describe "when complexity is overriden at query-level" do
-    before do
-      DummySchema.max_complexity = 100
-    end
-    let(:result) { DummySchema.execute(query_string, max_complexity: 7) }
-
-    it "is applied" do
-      assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result["errors"][0]["message"]
-    end
-  end
-end

data/spec/graphql/analysis/max_query_depth_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Analysis::MaxQueryDepth do
-  before do
-    @prev_max_depth = DummySchema.max_depth
-  end
-
-  after do
-    DummySchema.max_depth = @prev_max_depth
-  end
-
-  let(:result) { DummySchema.execute(query_string) }
-  let(:query_string) { "
-    {
-      cheese(id: 1) {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              similarCheese(source: SHEEP) {
-                similarCheese(source: SHEEP) {
-                  id
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  "}
-
-  describe "when the query is deeper than max depth" do
-    it "adds an error message for a too-deep query" do
-      assert_equal "Query has depth of 7, which exceeds max depth of 5", result["errors"][0]["message"]
-    end
-  end
-
-  describe "when the query specifies a different max_depth" do
-    let(:result) { DummySchema.execute(query_string, max_depth: 100) }
-
-    it "obeys that max_depth" do
-      assert_equal nil, result["errors"]
-    end
-  end
-
-  describe "When the query is not deeper than max_depth" do
-    before do
-      DummySchema.max_depth = 100
-    end
-
-    it "doesn't add an error" do
-      assert_equal nil, result["errors"]
-    end
-  end
-
-  describe "when the max depth isn't set" do
-    before do
-      DummySchema.max_depth = nil
-    end
-
-    it "doesn't add an error message" do
-      assert_equal nil, result["errors"]
-    end
-  end
-
-  describe "when a fragment exceeds max depth" do
-    before do
-      DummySchema.max_depth = 4
-    end
-
-    let(:query_string) { "
-      {
-        cheese(id: 1) {
-          ...moreFields
-        }
-      }
-
-      fragment moreFields on Cheese {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            similarCheese(source: SHEEP) {
-              ...evenMoreFields
-            }
-          }
-        }
-      }
-
-      fragment evenMoreFields on Cheese {
-        similarCheese(source: SHEEP) {
-          similarCheese(source: SHEEP) {
-            id
-          }
-        }
-      }
-    "}
-
-    it "adds an error message for a too-deep query" do
-      assert_equal 1, result["errors"].length
-    end
-  end
-end