graphql_cody 1.13.0

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,50 @@
+# 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 used_directives[directive_name]
+            add_error(GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
+              "The directive \"#{directive_name}\" can only be used once at this location.",
+              nodes: [used_directives[directive_name], ast_directive],
+              directive: directive_name,
+            ))
+          else
+            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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    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)
+
+              if !validation_result.valid?
+                problems = validation_result.problems
+                first_problem = problems && problems.first
+                if first_problem
+                  error_message = first_problem["message"]
+                end
+
+                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
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableDefaultValuesAreCorrectlyTypedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :type_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :INVALID_TYPE         => "defaultValueInvalidType",
+        :INVALID_ON_NON_NULL  => "defaultValueInvalidOnNonNullVariable",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, type: nil, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        @type_name = type
+        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
+        }.tap { |h| h["typeName"] = type_name unless type_name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module VariableNamesAreUnique
+      def on_operation_definition(node, parent)
+        var_defns = node.variables
+        if var_defns.any?
+          vars_by_name = Hash.new { |h, k| h[k] = [] }
+          var_defns.each { |v| vars_by_name[v.name] << v }
+          vars_by_name.each do |name, defns|
+            if defns.size > 1
+              add_error(GraphQL::StaticValidation::VariableNamesAreUniqueError.new(
+                "There can only be one variable named \"#{name}\"",
+                nodes: defns,
+                name: name
+              ))
+            end
+          end
+        end
+        super
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module VariableUsagesAreAllowed
+      def initialize(*)
+        super
+        # holds { name => ast_node } pairs
+        @declared_variables = {}
+      end
+
+      def on_operation_definition(node, parent)
+        @declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+        super
+      end
+
+      def on_argument(node, parent)
+        node_values = if node.value.is_a?(Array)
+          node.value
+        else
+          [node.value]
+        end
+        node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
+
+        if node_values.any?
+          argument_owner = case parent
+          when GraphQL::Language::Nodes::Field
+            context.field_definition
+          when GraphQL::Language::Nodes::Directive
+            context.directive_definition
+          when GraphQL::Language::Nodes::InputObject
+            arg_type = context.argument_definition.type.unwrap
+            if arg_type.kind.input_object?
+              arg_type
+            else
+              # This is some kind of error
+              nil
+            end
+          else
+            raise("Unexpected argument parent: #{parent}")
+          end
+
+          node_values.each do |node_value|
+            var_defn_ast = @declared_variables[node_value.name]
+            # Might be undefined :(
+            # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
+            var_defn_ast && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
+          end
+        end
+        super
+      end
+
+      private
+
+      def validate_usage(argument_owner, arg_node, ast_var)
+        var_type = context.schema.type_from_ast(ast_var.type, context: context)
+        if var_type.nil?
+          return
+        end
+        if !ast_var.default_value.nil?
+          unless var_type.kind.non_null?
+            # If the value is required, but the argument is not,
+            # and yet there's a non-nil default, then we impliclty
+            # make the argument also a required type.
+            var_type = var_type.to_non_null_type
+          end
+        end
+
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
+        arg_defn_type = arg_defn.type
+
+        var_inner_type = var_type.unwrap
+        arg_inner_type = arg_defn_type.unwrap
+
+        var_type = wrap_var_type_with_depth_of_arg(var_type, arg_node)
+
+        if var_inner_type != arg_inner_type
+          create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
+        elsif list_dimension(var_type) != list_dimension(arg_defn_type)
+          create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node)
+        elsif !non_null_levels_match(arg_defn_type, var_type)
+          create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
+        end
+      end
+
+      def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
+        add_error(GraphQL::StaticValidation::VariableUsagesAreAllowedError.new(
+          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_type_signature} / #{arg_defn.type.to_type_signature})",
+          nodes: arg_node,
+          name: ast_var.name,
+          type: var_type.to_type_signature,
+          argument: arg_node.name,
+          error: error_message
+        ))
+      end
+
+      def wrap_var_type_with_depth_of_arg(var_type, arg_node)
+        arg_node_value = arg_node.value
+        return var_type unless arg_node_value.is_a?(Array)
+        new_var_type = var_type
+
+        depth_of_array(arg_node_value).times do
+          # Since the array _is_ present, treat it like a non-null type
+          # (It satisfies a non-null requirement AND a nullable requirement)
+          new_var_type = new_var_type.to_list_type.to_non_null_type
+        end
+
+        new_var_type
+      end
+
+      # @return [Integer] Returns the max depth of `array`, or `0` if it isn't an array at all
+      def depth_of_array(array)
+        case array
+        when Array
+          max_child_depth = 0
+          array.each do |item|
+            item_depth = depth_of_array(item)
+            if item_depth > max_child_depth
+              max_child_depth = item_depth
+            end
+          end
+          1 + max_child_depth
+        else
+          0
+        end
+      end
+
+      def list_dimension(type)
+        if type.kind.list?
+          1 + list_dimension(type.of_type)
+        elsif type.kind.non_null?
+          list_dimension(type.of_type)
+        else
+          0
+        end
+      end
+
+      def non_null_levels_match(arg_type, var_type)
+        if arg_type.kind.non_null? && !var_type.kind.non_null?
+          false
+        elsif arg_type.kind.wraps? && var_type.kind.wraps?
+          # If var_type is a non-null wrapper for a type, and arg_type is nullable, peel off the wrapper
+          # That way, a var_type of `[DairyAnimal]!` works with an arg_type of `[DairyAnimal]`
+          if var_type.kind.non_null? && !arg_type.kind.non_null?
+            var_type = var_type.of_type
+          end
+          non_null_levels_match(arg_type.of_type, var_type.of_type)
+        else
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableUsagesAreAllowedError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :variable_name
+      attr_reader :argument_name
+      attr_reader :error_message
+
+      def initialize(message, path: nil, nodes: [], type:, name:, argument:, error:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @variable_name = name
+        @argument_name = argument
+        @error_message = error
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name,
+          "typeName" => type_name,
+          "argumentName" => argument_name,
+          "errorMessage" => error_message
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "variableMismatch"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module VariablesAreInputTypes
+      def on_variable_definition(node, parent)
+        type_name = get_type_name(node.type)
+        type = context.warden.get_type(type_name)
+
+        if type.nil?
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type_name} isn't a defined input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
+        elsif !type.kind.input?
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type.graphql_name} isn't a valid input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
+        end
+
+        super
+      end
+
+      private
+
+      def get_type_name(ast_type)
+        if ast_type.respond_to?(:of_type)
+          get_type_name(ast_type.of_type)
+        else
+          ast_type.name
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    # The problem is
+    #   - Variable $usage must be determined at the OperationDefinition level
+    #   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
+    #
+    #  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
+    #
+    # `graphql-js` solves this problem by:
+    #   - re-visiting the AST for each validator
+    #   - allowing validators to say `followSpreads: true`
+    #
+    module VariablesAreUsedAndDefined
+      class VariableUsage
+        attr_accessor :ast_node, :used_by, :declared_by, :path
+        def used?
+          !!@used_by
+        end
+
+        def declared?
+          !!@declared_by
+        end
+      end
+
+      def initialize(*)
+        super
+        @variable_usages_for_context = Hash.new {|hash, key| hash[key] = Hash.new {|h, k| h[k] = VariableUsage.new } }
+        @spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
+        @variable_context_stack = []
+      end
+
+      def on_operation_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        # mark variables as defined:
+        var_hash = @variable_usages_for_context[node]
+        node.variables.each { |var|
+          var_usage = var_hash[var.name]
+          var_usage.declared_by = node
+          var_usage.path = context.path
+        }
+        super
+        @variable_context_stack.pop
+      end
+
+      def on_fragment_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        super
+        @variable_context_stack.pop
+      end
+
+      # For FragmentSpreads:
+      #  - find the context on the stack
+      #  - mark the context as containing this spread
+      def on_fragment_spread(node, parent)
+        variable_context = @variable_context_stack.last
+        @spreads_for_context[variable_context] << node.name
+        super
+      end
+
+      # For VariableIdentifiers:
+      #  - mark the variable as used
+      #  - assign its AST node
+      def on_variable_identifier(node, parent)
+        usage_context = @variable_context_stack.last
+        declared_variables = @variable_usages_for_context[usage_context]
+        usage = declared_variables[node.name]
+        usage.used_by = usage_context
+        usage.ast_node = node
+        usage.path = context.path
+        super
+      end
+
+      def on_document(node, parent)
+        super
+        fragment_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+        operation_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+
+        operation_definitions.each do |node, node_variables|
+          follow_spreads(node, node_variables, @spreads_for_context, fragment_definitions, [])
+          create_errors(node_variables)
+        end
+      end
+
+      private
+
+      # Follow spreads in `node`, looking them up from `spreads_for_context` and finding their match in `fragment_definitions`.
+      # Use those fragments to update {VariableUsage}s in `parent_variables`.
+      # Avoid infinite loops by skipping anything in `visited_fragments`.
+      def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
+        spreads = spreads_for_context[node] - visited_fragments
+        spreads.each do |spread_name|
+          def_node = nil
+          variables = nil
+          # Implement `.find` by hand to avoid Ruby's internal allocations
+          fragment_definitions.each do |frag_def_node, vars|
+            if frag_def_node.name == spread_name
+              def_node = frag_def_node
+              variables = vars
+              break
+            end
+          end
+
+          next if !def_node
+          visited_fragments << spread_name
+          variables.each do |name, child_usage|
+            parent_usage = parent_variables[name]
+            if child_usage.used?
+              parent_usage.ast_node   = child_usage.ast_node
+              parent_usage.used_by    = child_usage.used_by
+              parent_usage.path       = child_usage.path
+            end
+          end
+          follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
+        end
+      end
+
+      # Determine all the error messages,
+      # Then push messages into the validation context
+      def create_errors(node_variables)
+        # Declared but not used:
+        node_variables
+          .select { |name, usage| usage.declared? && !usage.used? }
+          .each { |var_name, usage|
+            declared_by_error_name = usage.declared_by.name || "anonymous #{usage.declared_by.operation_type}"
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is declared by #{declared_by_error_name} but not used",
+              nodes: usage.declared_by,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_USED]
+            ))
+          }
+
+        # Used but not declared:
+        node_variables
+          .select { |name, usage| usage.used? && !usage.declared? }
+          .each { |var_name, usage|
+            used_by_error_name = usage.used_by.name || "anonymous #{usage.used_by.operation_type}"
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is used by #{used_by_error_name} but not declared",
+              nodes: usage.ast_node,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_DEFINED]
+            ))
+          }
+      end
+    end
+  end
+end