graphql 0.16.0 → 2.0.15

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module OneOfInputObjectsAreValid
+      def on_input_object(node, parent)
+        return super unless parent.is_a?(GraphQL::Language::Nodes::Argument)
+
+        parent_type = get_parent_type(context, parent)
+        return super unless parent_type && parent_type.kind.input_object? && parent_type.one_of?
+
+        validate_one_of_input_object(node, context, parent_type)
+        super
+      end
+
+      private
+
+      def validate_one_of_input_object(ast_node, context, parent_type)
+        present_fields = ast_node.arguments.map(&:name)
+        input_object_type = parent_type.to_type_signature
+
+        if present_fields.count != 1
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "OneOf Input Object '#{input_object_type}' must specify exactly one key.",
+              path: context.path,
+              nodes: ast_node,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        field = present_fields.first
+        value = ast_node.arguments.first.value
+
+        if value.is_a?(GraphQL::Language::Nodes::NullValue)
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "Argument '#{input_object_type}.#{field}' must be non-null.",
+              path: [*context.path, field],
+              nodes: ast_node.arguments.first,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variable_name = value.name
+          variable_type = @declared_variables[variable_name].type
+
+          unless variable_type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(
+              OneOfInputObjectsAreValidError.new(
+                "Variable '#{variable_name}' must be non-nullable to be used for OneOf Input Object '#{input_object_type}'.",
+                path: [*context.path, field],
+                nodes: ast_node,
+                input_object_type: input_object_type
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class OneOfInputObjectsAreValidError < StaticValidation::Error
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "inputObjectType" => input_object_type
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "invalidOneOfInputObject"
+      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/query_root_exists.rb

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

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

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

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

@@ -1,36 +1,37 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class RequiredArgumentsArePresent
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        v = context.visitor
-        v[GraphQL::Language::Nodes::Field] << -> (node, parent) { validate_field(node, context) }
-        v[GraphQL::Language::Nodes::Directive] << -> (node, parent) { validate_directive(node, context) }
+    module RequiredArgumentsArePresent
+      def on_field(node, _parent)
+        assert_required_args(node, field_definition)
+        super
       end
 
-      private
-
-      def validate_directive(ast_directive, context)
-        directive_defn = context.schema.directives[ast_directive.name]
-        assert_required_args(ast_directive, directive_defn, context)
+      def on_directive(node, _parent)
+        directive_defn = context.schema_directives[node.name]
+        assert_required_args(node, directive_defn)
+        super
       end
 
-      def validate_field(ast_field, context)
-        return if context.skip_field?(ast_field.name)
-        defn = context.field_definition
-        assert_required_args(ast_field, defn, context)
-      end
+      private
 
-      def assert_required_args(ast_node, defn, context)
+      def assert_required_args(ast_node, defn)
+        args = defn.arguments(context.query.context)
+        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = defn.arguments.values
-          .select { |a| a.type.kind.non_null? }
+        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?
-          context.errors << message("#{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,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

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

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

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

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

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module UniqueDirectivesPerLocation
+      DIRECTIVE_NODE_HOOKS = [
+        :on_fragment_definition,
+        :on_fragment_spread,
+        :on_inline_fragment,
+        :on_operation_definition,
+        :on_scalar_type_definition,
+        :on_object_type_definition,
+        :on_input_value_definition,
+        :on_field_definition,
+        :on_interface_type_definition,
+        :on_union_type_definition,
+        :on_enum_type_definition,
+        :on_enum_value_definition,
+        :on_input_object_type_definition,
+        :on_field,
+      ]
+
+      DIRECTIVE_NODE_HOOKS.each do |method_name|
+        define_method(method_name) do |node, parent|
+          if node.directives.any?
+            validate_directive_location(node)
+          end
+          super(node, parent)
+        end
+      end
+
+      private
+
+      def validate_directive_location(node)
+        used_directives = {}
+        node.directives.each do |ast_directive|
+          directive_name = ast_directive.name
+          if (first_node = used_directives[directive_name])
+            @directives_are_unique_errors_by_first_node ||= {}
+            err = @directives_are_unique_errors_by_first_node[first_node] ||= begin
+              error = GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
+                "The directive \"#{directive_name}\" can only be used once at this location.",
+                nodes: [used_directives[directive_name]],
+                directive: directive_name,
+              )
+              add_error(error)
+              error
+            end
+            err.nodes << ast_directive
+          elsif !((dir_defn = context.schema_directives[directive_name]) && dir_defn.repeatable?)
+            used_directives[directive_name] = ast_directive
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class UniqueDirectivesPerLocationError < 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
+        "directiveNotUniqueForLocation"
+      end
+    end
+  end
+end

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

@@ -1,27 +1,45 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableDefaultValuesAreCorrectlyTyped
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module VariableDefaultValuesAreCorrectlyTyped
+      def on_variable_definition(node, parent)
+        if !node.default_value.nil?
+          value = node.default_value
+          if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+              "Non-null variable $#{node.name} can't have a default value",
+              nodes: node,
+              name: node.name,
+              error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
+            ))
+          else
+            type = context.schema.type_from_ast(node.type, context: context)
+            if type.nil?
+              # This is handled by another validator
+            else
+              validation_result = context.validate_literal(value, type)
 
-      def validate(context)
-        literal_validator = GraphQL::StaticValidation::LiteralValidator.new
-        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
-          if !node.default_value.nil?
-            validate_default_value(node, literal_validator, context)
-          end
-        }
-      end
+              if !validation_result.valid?
+                problems = validation_result.problems
+                first_problem = problems && problems.first
+                if first_problem
+                  error_message = first_problem["explanation"]
+                end
 
-      def validate_default_value(node, literal_validator, context)
-        value = node.default_value
-        if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-          context.errors << message("Non-null variable $#{node.name} can't have a default value", node)
-        else
-          type = context.schema.type_from_ast(node.type)
-          if !literal_validator.validate(value, type)
-            context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node)
+                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
+                add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+                  error_message,
+                  nodes: node,
+                  name: node.name,
+                  type: type.to_type_signature,
+                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
+                ))
+              end
+            end
           end
         end
+
+        super
       end
     end
   end