graphql 1.9.0.pre1 → 1.9.0.pre2

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

@@ -7,7 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            context.errors << message("Fragment #{defn.name} contains an infinite loop", defn.node, path: defn.path)
+            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+              "Fragment #{defn.name} contains an infinite loop",
+              nodes: defn.node,
+              path: defn.path,
+              name: defn.name
+            )
           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

@@ -4,7 +4,10 @@ module GraphQL
     module FragmentsAreNamed
       def on_fragment_definition(node, _parent)
         if node.name.nil?
-          add_error("Fragment definition has no name", node)
+          add_error(GraphQL::StaticValidation::FragmentsAreNamedError.new(
+            "Fragment definition has no name",
+            nodes: node
+          ))
         end
         super
       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

@@ -21,7 +21,11 @@ module GraphQL
           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("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node)
+            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

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

@@ -7,13 +7,23 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.unmet_dependencies.each do |op_defn, spreads|
           spreads.each do |fragment_spread|
-            add_error("Fragment #{fragment_spread.name} was used, but not defined", fragment_spread.node, path: fragment_spread.path)
+            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.name.nil?
-            add_error("Fragment #{fragment.name} was defined, but not used", fragment.node, path: fragment.path)
+          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

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/mutation_root_exists.rb

@@ -4,7 +4,10 @@ module GraphQL
     module MutationRootExists
       def on_operation_definition(node, _parent)
         if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
-          add_error('Schema is not configured for mutations', node)
+          add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
+            'Schema is not configured for mutations',
+            nodes: node
+          ))
         else
           super
         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

@@ -2,7 +2,7 @@
 module GraphQL
   module StaticValidation
     module NoDefinitionsArePresent
-      include GraphQL::StaticValidation::Message::MessageHelper
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
       def initialize(*)
         super
@@ -33,7 +33,7 @@ module GraphQL
       def on_document(node, parent)
         super
         if @schema_definition_nodes.any?
-          add_error(%|Query cannot contain schema definitions|, @schema_definition_nodes)
+          add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
         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

@@ -18,9 +18,16 @@ module GraphQL
 
         @operation_names.each do |name, nodes|
           if name.nil? && op_count > 1
-            add_error(%|Operation name is required when multiple operations are present|, nodes)
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name is required when multiple operations are present|,
+              nodes: nodes
+            ))
           elsif nodes.length > 1
-            add_error(%|Operation name "#{name}" must be unique|, nodes)
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name "#{name}" must be unique|,
+              nodes: nodes,
+              name: name
+            ))
           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

@@ -23,7 +23,13 @@ module GraphQL
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?
-          add_error("#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}", ast_node)
+          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

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,47 @@
+# 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)
+        defn = context.field_definition
+        parent_type = context.warden.arguments(defn)
+          .find{|f| f.name == 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 = parent_type.arguments
+          .select{|k,v| v.type.kind.non_null?}
+          .keys
+
+        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 = parent_type.arguments[missing_field].type
+          add_error(RequiredInputObjectAttributesArePresentError.new(
+            "Argument '#{missing_field}' on InputObject '#{parent_type}' is required. Expected type #{missing_field_type}",
+            argument_name: missing_field,
+            argument_type: missing_field_type.to_s,
+            input_object_type: parent_type.to_s,
+            path: path,
+            nodes: ast_node,
+          ))
+        end
+      end
+    end
+  end
+end