graphql_cody 1.13.0

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FragmentsAreFinite
+      def on_document(_n, _p)
+        super
+        dependency_map = context.dependencies
+        dependency_map.cyclical_definitions.each do |defn|
+          if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+              "Fragment #{defn.name} contains an infinite loop",
+              nodes: defn.node,
+              path: defn.path,
+              name: defn.name
+            ))
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FragmentsAreNamed
+      def on_fragment_definition(node, _parent)
+        if node.name.nil?
+          add_error(GraphQL::StaticValidation::FragmentsAreNamedError.new(
+            "Fragment definition has no name",
+            nodes: node
+          ))
+        end
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreNamedError < 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
+        "anonymousFragment"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FragmentsAreOnCompositeTypes
+      def on_fragment_definition(node, parent)
+        validate_type_is_composite(node) && super
+      end
+
+      def on_inline_fragment(node, parent)
+        validate_type_is_composite(node) && super
+      end
+
+      private
+
+      def validate_type_is_composite(node)
+        node_type = node.type
+        if node_type.nil?
+          # Inline fragment on the same type
+          true
+        else
+          type_name = node_type.to_query_string
+          type_def = context.warden.get_type(type_name)
+          if type_def.nil? || !type_def.kind.composite?
+            add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
+              "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",
+              nodes: node,
+              type: type_name
+            ))
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module FragmentsAreUsed
+      def on_document(node, parent)
+        super
+        dependency_map = context.dependencies
+        dependency_map.unmet_dependencies.each do |op_defn, spreads|
+          spreads.each do |fragment_spread|
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment_spread.name} was used, but not defined",
+              nodes: fragment_spread.node,
+              path: fragment_spread.path,
+              fragment: fragment_spread.name
+            ))
+          end
+        end
+
+        dependency_map.unused_dependencies.each do |fragment|
+          if fragment && !fragment.name.nil?
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment.name} was defined, but not used",
+              nodes: fragment.node,
+              path: fragment.path,
+              fragment: fragment.name
+            ))
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module InputObjectNamesAreUnique
+      def on_input_object(node, parent)
+        validate_input_fields(node)
+        super
+      end
+
+      private
+
+      def validate_input_fields(node)
+        input_field_defns = node.arguments
+        input_fields_by_name = Hash.new { |h, k| h[k] = [] }
+        input_field_defns.each { |a| input_fields_by_name[a.name] << a }
+
+        input_fields_by_name.each do |name, defns|
+          if defns.size > 1
+            error = GraphQL::StaticValidation::InputObjectNamesAreUniqueError.new(
+              "There can be only one input field named \"#{name}\"",
+              nodes: defns,
+              name: name
+            )
+            add_error(error)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class InputObjectNamesAreUniqueError < 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
+        "inputFieldNotUnique"
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module MutationRootExists
+      def on_operation_definition(node, _parent)
+        if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
+          add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
+            'Schema is not configured for mutations',
+            nodes: node
+          ))
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class MutationRootExistsError < 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
+        "missingMutationConfiguration"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module NoDefinitionsArePresent
+      include GraphQL::StaticValidation::Error::ErrorHelper
+
+      def initialize(*)
+        super
+        @schema_definition_nodes = []
+      end
+
+      def on_invalid_node(node, parent)
+        @schema_definition_nodes << node
+        nil
+      end
+
+      alias :on_directive_definition :on_invalid_node
+      alias :on_schema_definition :on_invalid_node
+      alias :on_scalar_type_definition :on_invalid_node
+      alias :on_object_type_definition :on_invalid_node
+      alias :on_input_object_type_definition :on_invalid_node
+      alias :on_interface_type_definition :on_invalid_node
+      alias :on_union_type_definition :on_invalid_node
+      alias :on_enum_type_definition :on_invalid_node
+      alias :on_schema_extension :on_invalid_node
+      alias :on_scalar_type_extension :on_invalid_node
+      alias :on_object_type_extension :on_invalid_node
+      alias :on_input_object_type_extension :on_invalid_node
+      alias :on_interface_type_extension :on_invalid_node
+      alias :on_union_type_extension :on_invalid_node
+      alias :on_enum_type_extension :on_invalid_node
+
+      def on_document(node, parent)
+        super
+        if @schema_definition_nodes.any?
+          add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class NoDefinitionsArePresentError < 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
+        "queryContainsSchemaDefinitions"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module OperationNamesAreValid
+      def initialize(*)
+        super
+        @operation_names = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def on_operation_definition(node, parent)
+        @operation_names[node.name] << node
+        super
+      end
+
+      def on_document(node, parent)
+        super
+        op_count = @operation_names.values.inject(0) { |m, v| m + v.size }
+
+        @operation_names.each do |name, nodes|
+          if name.nil? && op_count > 1
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name is required when multiple operations are present|,
+              nodes: nodes
+            ))
+          elsif nodes.length > 1
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name "#{name}" must be unique|,
+              nodes: nodes,
+              name: name
+            ))
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module RequiredArgumentsArePresent
+      def on_field(node, _parent)
+        assert_required_args(node, field_definition)
+        super
+      end
+
+      def on_directive(node, _parent)
+        directive_defn = context.schema.directives[node.name]
+        assert_required_args(node, directive_defn)
+        super
+      end
+
+      private
+
+      def assert_required_args(ast_node, defn)
+        present_argument_names = ast_node.arguments.map(&:name)
+        required_argument_names = context.warden.arguments(defn)
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
+          .map(&:name)
+
+        missing_names = required_argument_names - present_argument_names
+        if missing_names.any?
+          add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(
+            "#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}",
+            nodes: ast_node,
+            class_name: ast_node.class.name.split("::").last,
+            name: ast_node.name,
+            arguments: "#{missing_names.join(", ")}"
+          ))
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module RequiredInputObjectAttributesArePresent
+      def on_input_object(node, parent)
+        if parent.is_a? GraphQL::Language::Nodes::Argument
+          validate_input_object(node, context, parent)
+        end
+        super
+      end
+
+      private
+
+      def get_parent_type(context, parent)
+        # If argument_definition is defined we're at nested object
+        # and need to refer to the containing input object type rather
+        # than the field_definition.
+        # h/t @rmosolgo
+        arg_defn = context.argument_definition
+
+        # Double checking that arg_defn is an input object as nested
+        # scalars, namely JSON, can make it to this branch
+        defn = if arg_defn && arg_defn.type.unwrap.kind.input_object?
+          arg_defn.type.unwrap
+        else
+          context.directive_definition || context.field_definition
+        end
+
+        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
+        parent_type ? parent_type.type.unwrap : nil
+      end
+
+      def validate_input_object(ast_node, context, parent)
+        parent_type = get_parent_type(context, parent)
+        return unless parent_type && parent_type.kind.input_object?
+
+        required_fields = context.warden.arguments(parent_type)
+          .select{|arg| arg.type.kind.non_null?}
+          .map(&:graphql_name)
+
+        present_fields = ast_node.arguments.map(&:name)
+        missing_fields = required_fields - present_fields
+
+        missing_fields.each do |missing_field|
+          path = [*context.path, missing_field]
+          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
+          add_error(RequiredInputObjectAttributesArePresentError.new(
+            "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
+            argument_name: missing_field,
+            argument_type: missing_field_type.to_type_signature,
+            input_object_type: parent_type.to_type_signature,
+            path: path,
+            nodes: ast_node,
+          ))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class RequiredInputObjectAttributesArePresentError < StaticValidation::Error
+      attr_reader :argument_type
+      attr_reader :argument_name
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, argument_type:, argument_name:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @argument_type = argument_type
+        @argument_name = argument_name
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "argumentName" => argument_name,
+          "argumentType" => argument_type,
+          "inputObjectType" => input_object_type,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingRequiredInputObjectAttribute"
+      end
+    end
+  end
+end