graphql_cody 1.13.0

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module ArgumentLiteralsAreCompatible
+      def on_argument(node, parent)
+        # Check the child arguments first;
+        # don't add a new error if one of them reports an error
+        super
+
+        # Don't validate variables here
+        if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          return
+        end
+
+        if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+          parent_defn = parent_definition(parent)
+
+          if parent_defn && (arg_defn = context.warden.get_argument(parent_defn, node.name))
+            validation_result = context.validate_literal(node.value, arg_defn.type)
+            if !validation_result.valid?
+              kind_of_node = node_type(parent)
+              error_arg_name = parent_name(parent, parent_defn)
+              string_value = if node.value == Float::INFINITY
+                ""
+              else
+                " (#{GraphQL::Language::Printer.new.print(node.value)})"
+              end
+
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                message = first_problem["message"]
+                # This is some legacy stuff from when `CoercionError` was raised thru the stack
+                if message
+                  coerce_extensions = first_problem["extensions"] || {
+                    "code" => "argumentLiteralsIncompatible"
+                  }
+                end
+              end
+
+              error_options = {
+                nodes: parent,
+                type: kind_of_node,
+                argument_name: node.name,
+                argument: arg_defn,
+                value: node.value
+              }
+              if coerce_extensions
+                error_options[:coerce_extensions] = coerce_extensions
+              end
+
+              message ||= "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'."
+
+              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
+                message,
+                **error_options
+              )
+
+              add_error(error)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :argument_name
+      attr_reader :argument
+      attr_reader :value
+
+      def initialize(message, path: nil, nodes: [], type:, argument_name: nil, extensions: nil, coerce_extensions: nil, argument: nil, value: nil)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @argument_name = argument_name
+        @extensions = extensions
+        @coerce_extensions = coerce_extensions
+        @argument = argument
+        @value = value
+      end
+
+      # A hash representation of this Message
+      def to_h
+        if @coerce_extensions
+          extensions = @coerce_extensions
+          # This is for legacy compat -- but this key is supposed to be a GraphQL type name :confounded:
+          extensions["typeName"] = "CoercionError"
+        else
+          extensions = {
+            "code" => code,
+            "typeName" => type_name
+          }
+
+          if argument_name
+            extensions["argumentName"] = argument_name
+          end
+        end
+
+        extensions.merge!(@extensions) unless @extensions.nil?
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "argumentLiteralsIncompatible"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module ArgumentNamesAreUnique
+      include GraphQL::StaticValidation::Error::ErrorHelper
+
+      def on_field(node, parent)
+        validate_arguments(node)
+        super
+      end
+
+      def on_directive(node, parent)
+        validate_arguments(node)
+        super
+      end
+
+      def validate_arguments(node)
+        argument_defns = node.arguments
+        if argument_defns.any?
+          args_by_name = Hash.new { |h, k| h[k] = [] }
+          argument_defns.each { |a| args_by_name[a.name] << a }
+          args_by_name.each do |name, defns|
+            if defns.size > 1
+              add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"", nodes: defns, name: name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module ArgumentsAreDefined
+      def on_argument(node, parent)
+        parent_defn = parent_definition(parent)
+
+        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+          super
+        elsif parent_defn
+          kind_of_node = node_type(parent)
+          error_arg_name = parent_name(parent, parent_defn)
+          add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'",
+            nodes: node,
+            name: error_arg_name,
+            type: kind_of_node,
+            argument_name: node.name,
+            parent: parent_defn
+          ))
+        else
+          # Some other weird error
+          super
+        end
+      end
+
+      private
+
+      # TODO smell: these methods are added to all visitors, since they're included in a module.
+      def parent_name(parent, type_defn)
+        case parent
+        when GraphQL::Language::Nodes::Field
+          parent.alias || parent.name
+        when GraphQL::Language::Nodes::InputObject
+          type_defn.graphql_name
+        when GraphQL::Language::Nodes::Argument, GraphQL::Language::Nodes::Directive
+          parent.name
+        else
+          raise "Invariant: Unexpected parent #{parent.inspect} (#{parent.class})"
+        end
+      end
+
+      def node_type(parent)
+        parent.class.name.split("::").last
+      end
+
+      def parent_definition(parent)
+        case parent
+        when GraphQL::Language::Nodes::InputObject
+          arg_defn = context.argument_definition
+          if arg_defn.nil?
+            nil
+          else
+            arg_ret_type = arg_defn.type.unwrap
+            if arg_ret_type.kind.input_object?
+              arg_ret_type
+            else
+              nil
+            end
+          end
+        when GraphQL::Language::Nodes::Directive
+          context.schema.directives[parent.name]
+        when GraphQL::Language::Nodes::Field
+          context.field_definition
+        else
+          raise "Unexpected argument parent: #{parent.class} (##{parent})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentsAreDefinedError < StaticValidation::Error
+      attr_reader :name
+      attr_reader :type_name
+      attr_reader :argument_name
+      attr_reader :parent
+
+      def initialize(message, path: nil, nodes: [], name:, type:, argument_name:, parent:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+        @type_name = type
+        @argument_name = argument_name
+        @parent = parent
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name,
+          "typeName" => type_name,
+          "argumentName" => argument_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "argumentNotAccepted"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module DirectivesAreDefined
+      def initialize(*)
+        super
+        @directive_names = context.warden.directives.map(&:graphql_name)
+      end
+
+      def on_directive(node, parent)
+        if !@directive_names.include?(node.name)
+          add_error(GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+            "Directive @#{node.name} is not defined",
+            nodes: node,
+            directive: node.name
+          ))
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module DirectivesAreInValidLocations
+      include GraphQL::Language
+
+      def on_directive(node, parent)
+        validate_location(node, parent, context.schema.directives)
+        super
+      end
+
+      private
+
+      LOCATION_MESSAGE_NAMES = {
+        GraphQL::Directive::QUERY =>               "queries",
+        GraphQL::Directive::MUTATION =>            "mutations",
+        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Directive::FIELD =>               "fields",
+        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+      }
+
+      SIMPLE_LOCATIONS = {
+        Nodes::Field =>               GraphQL::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+      }
+
+      SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
+
+      def validate_location(ast_directive, ast_parent, directives)
+        directive_defn = directives[ast_directive.name]
+        case ast_parent
+        when Nodes::OperationDefinition
+          required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
+          assert_includes_location(directive_defn, ast_directive, required_location)
+        when *SIMPLE_LOCATION_NODES
+          required_location = SIMPLE_LOCATIONS[ast_parent.class]
+          assert_includes_location(directive_defn, ast_directive, required_location)
+        else
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "Directives can't be applied to #{ast_parent.class.name}s",
+            nodes: ast_directive,
+            target: ast_parent.class.name
+          ))
+        end
+      end
+
+      def assert_includes_location(directive_defn, directive_ast, required_location)
+        if !directive_defn.locations.include?(required_location)
+          location_name = LOCATION_MESSAGE_NAMES[required_location]
+          allowed_location_names = directive_defn.locations.map { |loc| LOCATION_MESSAGE_NAMES[loc] }
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "'@#{directive_defn.graphql_name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})",
+            nodes: directive_ast,
+            target: location_name,
+            name: directive_defn.graphql_name
+          ))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class DirectivesAreInValidLocationsError < StaticValidation::Error
+      attr_reader :target_name
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], target:, name: nil)
+        super(message, path: path, nodes: nodes)
+        @target_name = target
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "targetName" => target_name
+        }.tap { |h| h["name"] = name unless name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "directiveCannotBeApplied"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FieldsAreDefinedOnType
+      def on_field(node, parent)
+        parent_type = @object_types[-2]
+        field = context.warden.get_field(parent_type, node.name)
+
+        if field.nil?
+          if parent_type.kind.union?
+            add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
+              "Selections can't be made directly on unions (see selections on #{parent_type.graphql_name})",
+              nodes: parent,
+              node_name: parent_type.graphql_name
+            ))
+          else
+            add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
+              nodes: node,
+              field: node.name,
+              type: parent_type.graphql_name
+            ))
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsAreDefinedOnTypeError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :field_name
+
+      def initialize(message, path: nil, nodes: [], type:, field:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @field_name = field
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "fieldName" => field_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "undefinedField"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    # Scalars _can't_ have selections
+    # Objects _must_ have selections
+    module FieldsHaveAppropriateSelections
+      include GraphQL::StaticValidation::Error::ErrorHelper
+
+      def on_field(node, parent)
+        field_defn = field_definition
+        if validate_field_selections(node, field_defn.type.unwrap)
+          super
+        end
+      end
+
+      def on_operation_definition(node, _parent)
+        if validate_field_selections(node, type_definition)
+          super
+        end
+      end
+
+      private
+
+
+      def validate_field_selections(ast_node, resolved_type)
+        msg = if resolved_type.nil?
+          nil
+        elsif resolved_type.kind.scalar? && ast_node.selections.any?
+          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
+          else
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          end
+        elsif resolved_type.kind.fields? && ast_node.selections.empty?
+          "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+        else
+          nil
+        end
+
+        if msg
+          node_name = case ast_node
+          when GraphQL::Language::Nodes::Field
+            "field '#{ast_node.name}'"
+          when GraphQL::Language::Nodes::OperationDefinition
+            if ast_node.name.nil?
+              "anonymous query"
+            else
+              "#{ast_node.operation_type} '#{ast_node.name}'"
+            end
+          else
+            raise("Unexpected node #{ast_node}")
+          end
+          extensions = {
+            "rule": "StaticValidation::FieldsHaveAppropriateSelections",
+            "name": node_name.to_s
+          }
+          unless resolved_type.nil?
+            extensions["type"] = resolved_type.to_type_signature
+          end
+          add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
+            msg % { node_name: node_name },
+            nodes: ast_node,
+            node_name: node_name.to_s,
+            type: resolved_type.nil? ? nil : resolved_type.graphql_name,
+          ))
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsHaveAppropriateSelectionsError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :node_name
+
+      def initialize(message, path: nil, nodes: [], node_name:, type: nil)
+        super(message, path: path, nodes: nodes)
+        @node_name = node_name
+        @type_name = type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "nodeName" => node_name
+        }.tap { |h| h["typeName"] = type_name unless type_name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "selectionMismatch"
+      end
+    end
+  end
+end