graphql_cody 1.13.0

data/lib/graphql/static_validation/rules/variables_are_used_and_defined_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariablesAreUsedAndDefinedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :VARIABLE_NOT_USED     => "variableNotUsed",
+        :VARIABLE_NOT_DEFINED  => "variableNotDefined",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        raise("Unexpected error type: #{error_type}") if !VIOLATIONS.values.include?(error_type)
+        @violation = error_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/type_stack.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    # - Ride along with `GraphQL::Language::Visitor`
+    # - Track type info, expose it to validators
+    class TypeStack
+      # These are jumping-off points for infering types down the tree
+      TYPE_INFERRENCE_ROOTS = [
+        GraphQL::Language::Nodes::OperationDefinition,
+        GraphQL::Language::Nodes::FragmentDefinition,
+      ]
+
+      # @return [GraphQL::Schema] the schema whose types are present in this document
+      attr_reader :schema
+
+      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
+      attr_reader :object_types
+
+      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::Field>] fields which have been entered
+      attr_reader :field_definitions
+
+      # Directives are pushed on, then popped off while traversing the tree
+      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
+      attr_reader :directive_definitions
+
+      # @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)
+        @schema = schema
+        @object_types = []
+        @field_definitions = []
+        @directive_definitions = []
+        @argument_definitions = []
+        @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
+
+
+      module FragmentWithTypeStrategy
+        def push(stack, node)
+          object_type = if node.type
+            stack.schema.get_type(node.type.name)
+          else
+            stack.object_types.last
+          end
+          if !object_type.nil?
+            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
+
+      module FragmentDefinitionStrategy
+        extend FragmentWithTypeStrategy
+        module_function
+        def push_path_member(stack, node)
+          stack.path.push("fragment #{node.name}")
+        end
+      end
+
+      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
+
+      module FieldStrategy
+        module_function
+        def push(stack, node)
+          parent_type = stack.object_types.last
+          parent_type = parent_type.unwrap
+
+          field_definition = stack.schema.get_field(parent_type, node.name)
+          stack.field_definitions.push(field_definition)
+          if !field_definition.nil?
+            next_object_type = field_definition.type
+            stack.object_types.push(next_object_type)
+          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
+
+      module DirectiveStrategy
+        module_function
+        def push(stack, node)
+          directive_defn = stack.schema.directives[node.name]
+          stack.directive_definitions.push(directive_defn)
+        end
+
+        def pop(stack, node)
+          stack.directive_definitions.pop
+        end
+      end
+
+      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.
+        def push(stack, node)
+          if stack.argument_definitions.last
+            arg_type = stack.argument_definitions.last.type.unwrap
+            if arg_type.kind.input_object?
+              argument_defn = arg_type.arguments[node.name]
+            else
+              argument_defn = nil
+            end
+          elsif stack.directive_definitions.last
+            argument_defn = stack.directive_definitions.last.arguments[node.name]
+          elsif stack.field_definitions.last
+            argument_defn = stack.field_definitions.last.arguments[node.name]
+          else
+            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
+
+      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
+end

data/lib/graphql/static_validation/validation_context.rb

@@ -0,0 +1,49 @@
+# 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. ({Language::Visitor#visit} is called in {Validator#validate})
+    #
+    # It provides access to the schema & fragments which validators may read from.
+    #
+    # It holds a list of errors which each validator may add to.
+    #
+    # It also provides limited access to the {TypeStack} instance,
+    # which tracks state as you climb in and out of different fields.
+    class ValidationContext
+      extend Forwardable
+
+      attr_reader :query, :errors, :visitor,
+        :on_dependency_resolve_handlers,
+        :max_errors
+
+      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+
+      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
+
+      def_delegators :@visitor,
+        :path, :type_definition, :field_definition, :argument_definition,
+        :parent_type_definition, :directive_definition, :object_types, :dependencies
+
+      def on_dependency_resolve(&handler)
+        @on_dependency_resolve_handlers << handler
+      end
+
+      def validate_literal(ast_value, type)
+        @literal_validator.validate(ast_value, type)
+      end
+
+      def too_many_errors?
+        @errors.length >= @max_errors
+      end
+    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

@@ -0,0 +1,96 @@
+# 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.
+    #
+    # By default, it's used by {GraphQL::Query}
+    #
+    # @example Validate a query
+    #   validator = GraphQL::StaticValidation::Validator.new(schema: MySchema)
+    #   query = GraphQL::Query.new(MySchema, query_string)
+    #   errors = validator.validate(query)[:errors]
+    #
+    class Validator
+      # @param schema [GraphQL::Schema]
+      # @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
+      end
+
+      # 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, validate: true, timeout: nil, max_errors: nil)
+        query.trace("validate", { validate: validate, query: query }) do
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
+          errors = if validate == false && can_skip_rewrite
+            []
+          else
+            rules_to_use = validate ? @rules : []
+            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
+
+            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
+                  # Attach legacy-style rules.
+                  # Only loop through rules if it has legacy-style rules
+                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+                    legacy_rules.each do |rule_class_or_module|
+                      if rule_class_or_module.method_defined?(:validate)
+                        GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
+                        GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
+                        rule_class_or_module.new.validate(context)
+                      end
+                    end
+                  end
+
+                  context.visitor.visit
+                end
+              end
+            rescue Timeout::Error
+              handle_timeout(query, context)
+            end
+
+            context.errors
+          end
+
+          irep = if errors.empty? && context
+            # Only return this if there are no errors and validation was actually run
+            context.visitor.rewrite_document
+          else
+            nil
+          end
+
+          {
+            errors: errors,
+            irep: irep,
+          }
+        end
+      rescue GraphQL::ExecutionError => e
+        {
+          errors: [e],
+          irep: nil,
+        }
+      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

@@ -0,0 +1,19 @@
+# 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"
+require "graphql/static_validation/no_validate_visitor"
+
+rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
+Dir.glob(rules_glob).each do |file|
+  require(file)
+end
+
+require "graphql/static_validation/all_rules"
+require "graphql/static_validation/default_visitor"
+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

data/lib/graphql/string_type.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition