class GraphQL::StaticValidation::Validator


errors = validator.validate(query)[:errors]
query = GraphQL::Query.new(MySchema, query_string)
validator = GraphQL::StaticValidation::Validator.new(schema: MySchema)
@example Validate a query
By default, it’s used by {GraphQL::Query}
Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.

def handle_timeout(query, context)

Parameters:
  • context (GraphQL::StaticValidation::ValidationContext) --
  • query (GraphQL::Query) -- 
def handle_timeout(query, context)
  context.errors << GraphQL::StaticValidation::ValidationTimeoutError.new(
    "Timeout on validation of query"
  )
end

def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)

Parameters:
  • rules (Array<#validate(context)>) -- a list of rules to use when validating
  • schema (GraphQL::Schema) -- 
def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)
  @schema = schema
  @rules = rules
end

def validate(query, validate: true, timeout: nil, max_errors: nil)

Returns:
  • (Array) -

Parameters:
  • 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.
  • timeout (Float) -- Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
  • validate (Boolean) --
  • query (GraphQL::Query) -- 
def validate(query, validate: true, timeout: nil, max_errors: nil)
  query.current_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)
      context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
      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: [e],
  }
end