graphql 0.16.0 → 2.0.15

data/lib/graphql/static_validation/type_stack.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
     # - Ride along with `GraphQL::Language::Visitor`
@@ -29,6 +30,9 @@ module GraphQL
       # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
       attr_reader :argument_definitions
 
+      # @return [Array<String>] fields which have been entered (by their AST name)
+      attr_reader :path
+
       # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
       # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
       def initialize(schema, visitor)
@@ -37,25 +41,21 @@ module GraphQL
         @field_definitions = []
         @directive_definitions = []
         @argument_definitions = []
-        visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
-        visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
+        @path = []
+
+        PUSH_STRATEGIES.each do |node_class, strategy|
+          visitor[node_class].enter << EnterWithStrategy.new(self, strategy)
+          visitor[node_class].leave << LeaveWithStrategy.new(self, strategy)
+        end
       end
 
       private
 
-      # Look up strategies by name and use singleton instance to push and pop
-      PUSH_STRATEGIES = Hash.new { |hash, key| hash[key] = get_strategy_for_node_class(key) }
 
-      def self.get_strategy_for_node_class(node_class)
-        node_class_name = node_class.name.split("::").last
-        strategy_key = "#{node_class_name}Strategy"
-        const_defined?(strategy_key) ? const_get(strategy_key).new : NullStrategy.new
-      end
-
-      class FragmentWithTypeStrategy
+      module FragmentWithTypeStrategy
         def push(stack, node)
           object_type = if node.type
-            stack.schema.types.fetch(node.type, nil)
+            stack.schema.get_type(node.type.name)
           else
             stack.object_types.last
           end
@@ -63,29 +63,48 @@ module GraphQL
             object_type = object_type.unwrap
           end
           stack.object_types.push(object_type)
+          push_path_member(stack, node)
         end
 
         def pop(stack, node)
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
-      class FragmentDefinitionStrategy < FragmentWithTypeStrategy; end
-      class InlineFragmentStrategy < FragmentWithTypeStrategy; end
+      module FragmentDefinitionStrategy
+        extend FragmentWithTypeStrategy
+        module_function
+        def push_path_member(stack, node)
+          stack.path.push("fragment #{node.name}")
+        end
+      end
 
-      class OperationDefinitionStrategy
+      module InlineFragmentStrategy
+        extend FragmentWithTypeStrategy
+        module_function
+        def push_path_member(stack, node)
+          stack.path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
+        end
+      end
+
+      module OperationDefinitionStrategy
+        module_function
         def push(stack, node)
           # eg, QueryType, MutationType
           object_type = stack.schema.root_type_for_operation(node.operation_type)
           stack.object_types.push(object_type)
+          stack.path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
         end
 
         def pop(stack, node)
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
-      class FieldStrategy
+      module FieldStrategy
+        module_function
         def push(stack, node)
           parent_type = stack.object_types.last
           parent_type = parent_type.unwrap
@@ -98,15 +117,18 @@ module GraphQL
           else
             stack.object_types.push(nil)
           end
+          stack.path.push(node.alias || node.name)
         end
 
         def pop(stack, node)
           stack.field_definitions.pop
           stack.object_types.pop
+          stack.path.pop
         end
       end
 
-      class DirectiveStrategy
+      module DirectiveStrategy
+        module_function
         def push(stack, node)
           directive_defn = stack.schema.directives[node.name]
           stack.directive_definitions.push(directive_defn)
@@ -117,7 +139,8 @@ module GraphQL
         end
       end
 
-      class ArgumentStrategy
+      module ArgumentStrategy
+        module_function
         # Push `argument_defn` onto the stack.
         # It's possible that `argument_defn` will be nil.
         # Push it anyways so `pop` has something to pop.
@@ -125,7 +148,7 @@ module GraphQL
           if stack.argument_definitions.last
             arg_type = stack.argument_definitions.last.type.unwrap
             if arg_type.kind.input_object?
-              argument_defn = arg_type.input_fields[node.name]
+              argument_defn = arg_type.arguments[node.name]
             else
               argument_defn = nil
             end
@@ -137,18 +160,56 @@ module GraphQL
             argument_defn = nil
           end
           stack.argument_definitions.push(argument_defn)
+          stack.path.push(node.name)
         end
 
         def pop(stack, node)
           stack.argument_definitions.pop
+          stack.path.pop
         end
       end
 
-      # A no-op strategy (don't handle this node)
-      class NullStrategy
-        def self.new; self; end
-        def self.push(stack, node);  end
-        def self.pop(stack, node);   end
+      module FragmentSpreadStrategy
+        module_function
+        def push(stack, node)
+          stack.path.push("... #{node.name}")
+        end
+
+        def pop(stack, node)
+          stack.path.pop
+        end
+      end
+
+      PUSH_STRATEGIES = {
+        GraphQL::Language::Nodes::FragmentDefinition => FragmentDefinitionStrategy,
+        GraphQL::Language::Nodes::InlineFragment => InlineFragmentStrategy,
+        GraphQL::Language::Nodes::FragmentSpread => FragmentSpreadStrategy,
+        GraphQL::Language::Nodes::Argument => ArgumentStrategy,
+        GraphQL::Language::Nodes::Field => FieldStrategy,
+        GraphQL::Language::Nodes::Directive => DirectiveStrategy,
+        GraphQL::Language::Nodes::OperationDefinition => OperationDefinitionStrategy,
+      }
+
+      class EnterWithStrategy
+        def initialize(stack, strategy)
+          @stack = stack
+          @strategy = strategy
+        end
+
+        def call(node, parent)
+          @strategy.push(@stack, node)
+        end
+      end
+
+      class LeaveWithStrategy
+        def initialize(stack, strategy)
+          @stack = stack
+          @strategy = strategy
+        end
+
+        def call(node, parent)
+          @strategy.pop(@stack, node)
+        end
       end
     end
   end

data/lib/graphql/static_validation/validation_context.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
     # The validation context gets passed to each validator.
     #
-    # It exposes a {GraphQL::Language::Visitor} where validators may add hooks. ({Visitor#visit} is called in {Validator#validate})
+    # It exposes a {GraphQL::Language::Visitor} where validators may add hooks. ({Language::Visitor#visit} is called in {Validator#validate})
     #
     # It provides access to the schema & fragments which validators may read from.
     #
@@ -11,63 +12,41 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      attr_reader :query, :schema, :document, :errors, :visitor, :fragments, :operations
-      def initialize(query)
-        @query = query
-        @schema = query.schema
-        @document = query.document
-        @fragments = {}
-        @operations = {}
-
-        document.definitions.each do |definition|
-          case definition
-          when GraphQL::Language::Nodes::FragmentDefinition
-            @fragments[definition.name] = definition
-          when GraphQL::Language::Nodes::OperationDefinition
-            @operations[definition.name] = definition
-          end
-        end
+      extend Forwardable
 
-        @errors = []
-        @visitor = GraphQL::Language::Visitor.new(document)
-        @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
-      end
+      attr_reader :query, :errors, :visitor,
+        :on_dependency_resolve_handlers,
+        :max_errors
 
-      def object_types
-        @type_stack.object_types
-      end
+      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      # @return [GraphQL::BaseType] The current object type
-      def type_definition
-        object_types.last
+      def initialize(query, visitor_class, max_errors)
+        @query = query
+        @literal_validator = LiteralValidator.new(context: query.context)
+        @errors = []
+        @max_errors = max_errors || Float::INFINITY
+        @on_dependency_resolve_handlers = []
+        @visitor = visitor_class.new(document, self)
       end
 
-      # @return [GraphQL::BaseType] The type which the current type came from
-      def parent_type_definition
-        object_types[-2]
-      end
+      def_delegators :@visitor,
+        :path, :type_definition, :field_definition, :argument_definition,
+        :parent_type_definition, :directive_definition, :object_types, :dependencies
 
-      # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
-      def field_definition
-        @type_stack.field_definitions.last
+      def on_dependency_resolve(&handler)
+        @on_dependency_resolve_handlers << handler
       end
 
-      # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
-      def directive_definition
-        @type_stack.directive_definitions.last
+      def validate_literal(ast_value, type)
+        @literal_validator.validate(ast_value, type)
       end
 
-      # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
-      def argument_definition
-        # Don't get the _last_ one because that's the current one.
-        # Get the second-to-last one, which is the parent of the current one.
-        @type_stack.argument_definitions[-2]
+      def too_many_errors?
+        @errors.length >= @max_errors
       end
 
-      # Don't try to validate dynamic fields
-      # since they aren't defined by the type system
-      def skip_field?(field_name)
-        GraphQL::Schema::DYNAMIC_FIELDS.include?(field_name)
+      def schema_directives
+        @schema_directives ||= schema.directives
       end
     end
   end

data/lib/graphql/static_validation/validation_timeout_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ValidationTimeoutError < StaticValidation::Error
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "validationTimeout"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validator.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+require "timeout"
+
 module GraphQL
   module StaticValidation
     # Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.
@@ -6,12 +9,12 @@ module GraphQL
     #
     # @example Validate a query
     #   validator = GraphQL::StaticValidation::Validator.new(schema: MySchema)
-    #   document = GraphQL.parse(query_string)
-    #   errors = validator.validate(document)
+    #   query = GraphQL::Query.new(MySchema, query_string)
+    #   errors = validator.validate(query)[:errors]
     #
     class Validator
       # @param schema [GraphQL::Schema]
-      # @param rule [Array<#validate(context)>] a list of rules to use when validating
+      # @param rules [Array<#validate(context)>] a list of rules to use when validating
       def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)
         @schema = schema
         @rules = rules
@@ -19,25 +22,53 @@ module GraphQL
 
       # Validate `query` against the schema. Returns an array of message hashes.
       # @param query [GraphQL::Query]
+      # @param validate [Boolean]
+      # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
+      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query)
-        context = GraphQL::StaticValidation::ValidationContext.new(query)
-        rewrite = GraphQL::InternalRepresentation::Rewrite.new
+      def validate(query, validate: true, timeout: nil, max_errors: nil)
+        query.trace("validate", { validate: validate, query: query }) do
+          errors = if validate == false
+            []
+          else
+            rules_to_use = validate ? @rules : []
+            visitor_class = BaseVisitor.including_rules(rules_to_use)
 
-        # Put this first so its enters and exits are always called
-        rewrite.validate(context)
-        @rules.each do |rules|
-          rules.new.validate(context)
-        end
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
-        context.visitor.visit
+            begin
+              # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
+              # A timeout value of 0 or nil will execute the block without any timeout.
+              Timeout::timeout(timeout) do
+                catch(:too_many_validation_errors) do
+                  context.visitor.visit
+                end
+              end
+            rescue Timeout::Error
+              handle_timeout(query, context)
+            end
 
+            context.errors
+          end
+
+          {
+            errors: errors,
+          }
+        end
+      rescue GraphQL::ExecutionError => e
         {
-          errors: context.errors.map(&:to_h),
-          # If there were errors, the irep is garbage
-          irep: context.errors.none? ? rewrite.operations : nil,
+          errors: [e],
         }
       end
+
+      # Invoked when static validation times out.
+      # @param query [GraphQL::Query]
+      # @param context [GraphQL::StaticValidation::ValidationContext]
+      def handle_timeout(query, context)
+        context.errors << GraphQL::StaticValidation::ValidationTimeoutError.new(
+          "Timeout on validation of query"
+        )
+      end
     end
   end
 end

data/lib/graphql/static_validation.rb

@@ -1,10 +1,12 @@
-require "graphql/static_validation/message"
-require "graphql/static_validation/arguments_validator"
+# frozen_string_literal: true
+require "graphql/static_validation/error"
+require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
+require "graphql/static_validation/validation_timeout_error"
 require "graphql/static_validation/literal_validator"
-
+require "graphql/static_validation/base_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
@@ -12,3 +14,4 @@ Dir.glob(rules_glob).each do |file|
 end
 
 require "graphql/static_validation/all_rules"
+require "graphql/static_validation/interpreter_visitor"

data/lib/graphql/string_encoding_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  class StringEncodingError < GraphQL::RuntimeTypeError
+    attr_reader :string, :field, :path
+    def initialize(str, context:)
+      @string = str
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "String #{str.inspect} was encoded as #{str.encoding}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". GraphQL requires an encoding compatible with UTF-8."
+      super(message)
+    end
+  end
+end