graphql 2.3.7 → 2.4.5

data/lib/graphql/static_validation/base_visitor.rb

@@ -10,6 +10,7 @@ module GraphQL
         @argument_definitions = []
         @directive_definitions = []
         @context = context
+        @types = context.query.types
         @schema = context.schema
         super(document)
       end
@@ -77,7 +78,7 @@ module GraphQL
 
         def on_field(node, parent)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name, @context.query.context)
+          field_definition = @types.field(parent_type, node.name)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -103,14 +104,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              @context.warden.get_argument(arg_type, node.name)
+              @types.argument(arg_type, node.name)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            @context.warden.get_argument(directive_defn, node.name)
+            @types.argument(directive_defn, node.name)
           elsif (field_defn = @field_definitions.last)
-            @context.warden.get_argument(field_defn, node.name)
+            @types.argument(field_defn, node.name)
           else
             nil
           end
@@ -170,7 +171,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @context.warden.get_type(node.type.name)
+            @types.type(node.type.name)
           else
             @object_types.last
           end

data/lib/graphql/static_validation/literal_validator.rb

@@ -5,7 +5,7 @@ module GraphQL
     class LiteralValidator
       def initialize(context:)
         @context = context
-        @warden = context.warden
+        @types = context.types
         @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
         @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
@@ -109,7 +109,7 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = @warden.arguments(type)
+        required_field_names = @types.arguments(type)
           .select { |argument| argument.type.kind.non_null? && !argument.default_value? }
           .map!(&:name)
 
@@ -119,7 +119,7 @@ module GraphQL
           missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
           results = missing_required_field_names.map do |name|
-            arg_type = @warden.get_argument(type, name).type
+            arg_type = @types.argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
           if type.one_of? && ast_node.arguments.size != 1
@@ -131,7 +131,7 @@ module GraphQL
 
       def present_input_field_values_are_valid(type, ast_node)
         results = ast_node.arguments.map do |value|
-          field = @warden.get_argument(type, value.name)
+          field = @types.argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
           field_type = field && field.type

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

@@ -15,7 +15,7 @@ module GraphQL
         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))
+          if parent_defn && (arg_defn = @types.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)

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

@@ -16,7 +16,7 @@ module GraphQL
 
       def validate_arguments(node)
         argument_defns = node.arguments
-        if argument_defns.any?
+        if !argument_defns.empty?
           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|

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

@@ -5,13 +5,14 @@ module GraphQL
       def on_argument(node, parent)
         parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+        if parent_defn && @types.argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, parent_defn)
+          arg_names = context.types.arguments(parent_defn).map(&:graphql_name)
           add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
-            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'",
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'#{context.did_you_mean_suggestion(node.name, arg_names)}",
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,

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

@@ -4,15 +4,15 @@ module GraphQL
     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)
+        if !@types.directive_exists?(node.name)
           @directives_are_defined_errors_by_name ||= {}
           error = @directives_are_defined_errors_by_name[node.name] ||= begin
+            @directive_names ||= @types.directives.map(&:graphql_name)
             err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(
-              "Directive @#{node.name} is not defined",
+              "Directive @#{node.name} is not defined#{context.did_you_mean_suggestion(node.name, @directive_names)}",
               nodes: [],
               directive: node.name
             )

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

@@ -19,6 +19,7 @@ module GraphQL
         GraphQL::Schema::Directive::FRAGMENT_DEFINITION => "fragment definitions",
         GraphQL::Schema::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
         GraphQL::Schema::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::VARIABLE_DEFINITION => "variable definitions",
       }
 
       SIMPLE_LOCATIONS = {
@@ -26,6 +27,7 @@ module GraphQL
         Nodes::InlineFragment =>      GraphQL::Schema::Directive::INLINE_FRAGMENT,
         Nodes::FragmentSpread =>      GraphQL::Schema::Directive::FRAGMENT_SPREAD,
         Nodes::FragmentDefinition =>  GraphQL::Schema::Directive::FRAGMENT_DEFINITION,
+        Nodes::VariableDefinition =>  GraphQL::Schema::Directive::VARIABLE_DEFINITION,
       }
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys

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

@@ -4,7 +4,7 @@ module GraphQL
     module FieldsAreDefinedOnType
       def on_field(node, parent)
         parent_type = @object_types[-2]
-        field = context.warden.get_field(parent_type, node.name)
+        field = context.query.types.field(parent_type, node.name)
 
         if field.nil?
           if parent_type.kind.union?
@@ -14,8 +14,11 @@ module GraphQL
               node_name: parent_type.graphql_name
             ))
           else
+            possible_fields = possible_fields(context, parent_type)
+            suggestion = context.did_you_mean_suggestion(node.name, possible_fields)
+            message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{suggestion}"
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
-              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
+              message,
               nodes: node,
               field: node.name,
               type: parent_type.graphql_name
@@ -25,6 +28,13 @@ module GraphQL
           super
         end
       end
+
+      private
+
+      def possible_fields(context, parent_type)
+        return EmptyObjects::EMPTY_ARRAY if parent_type.kind.leaf?
+        context.types.fields(parent_type).map(&:graphql_name)
+      end
     end
   end
 end

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

@@ -25,7 +25,7 @@ module GraphQL
       def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
-        elsif resolved_type.kind.scalar? && ast_node.selections.any?
+        elsif !ast_node.selections.empty? && resolved_type.kind.leaf?
           selection_strs = ast_node.selections.map do |n|
             case n
             when GraphQL::Language::Nodes::InlineFragment
@@ -38,7 +38,7 @@ module GraphQL
               raise "Invariant: unexpected selection node: #{n}"
             end
           end
-          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
+          "Selections can't be made on #{resolved_type.kind.name.sub("_", " ").downcase}s (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         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

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

@@ -117,8 +117,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.warden.get_type(fragment1.type.name)
-        fragment_type2 = context.warden.get_type(fragment2.type.name)
+        fragment_type1 = context.query.types.type(fragment1.type.name)
+        fragment_type2 = context.query.types.type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -170,7 +170,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.warden.get_type(fragment.type.name)
+        fragment_type = @types.type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -212,6 +212,7 @@ module GraphQL
 
       def find_conflict(response_key, field1, field2, mutually_exclusive: false)
         return if @conflict_count >= context.max_errors
+        return if field1.definition.nil? || field2.definition.nil?
 
         node1 = field1.node
         node2 = field2.node
@@ -340,10 +341,10 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.warden.get_field(owner_type, node.name)
+            definition = @types.field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type
+            fragment_type = node.type ? @types.type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
@@ -411,8 +412,8 @@ module GraphQL
               false
             else
               # Check if these two scopes have _any_ types in common.
-              possible_right_types = context.query.possible_types(type1)
-              possible_left_types = context.query.possible_types(type2)
+              possible_right_types = context.types.possible_types(type1)
+              possible_left_types = context.types.possible_types(type2)
               (possible_right_types & possible_left_types).empty?
             end
           end

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

@@ -28,7 +28,7 @@ module GraphQL
           frag_node = context.fragments[frag_spread.node.name]
           if frag_node
             fragment_child_name = frag_node.type.name
-            fragment_child = context.warden.get_type(fragment_child_name)
+            fragment_child = @types.type(fragment_child_name)
             # Might be non-existent type name
             if fragment_child
               validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
@@ -44,8 +44,8 @@ module GraphQL
           # It's not a valid fragment type, this error was handled someplace else
           return
         end
-        parent_types = context.warden.possible_types(parent_type.unwrap)
-        child_types = context.warden.possible_types(child_type.unwrap)
+        parent_types = @types.possible_types(parent_type.unwrap)
+        child_types = @types.possible_types(child_type.unwrap)
 
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""

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

@@ -21,10 +21,20 @@ module GraphQL
           true
         else
           type_name = fragment_node.type.name
-          type = context.warden.get_type(type_name)
+          type = @types.type(type_name)
           if type.nil?
+            @all_possible_fragment_type_names ||= begin
+              names = []
+              context.types.all_types.each do |type|
+                if type.kind.fields?
+                  names << type.graphql_name
+                end
+              end
+              names
+            end
+
             add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
-              "No such type #{type_name}, so it can't be a fragment condition",
+              "No such type #{type_name}, so it can't be a fragment condition#{context.did_you_mean_suggestion(type_name, @all_possible_fragment_type_names)}",
               nodes: fragment_node,
               type: type_name
             ))

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

@@ -19,7 +19,7 @@ module GraphQL
           true
         else
           type_name = node_type.to_query_string
-          type_def = context.warden.get_type(type_name)
+          type_def = @types.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)",

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

@@ -3,7 +3,7 @@ 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?
+        if node.operation_type == 'mutation' && context.query.types.mutation_root.nil?
           add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
             'Schema is not configured for mutations',
             nodes: node

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

@@ -32,7 +32,7 @@ module GraphQL
 
       def on_document(node, parent)
         super
-        if @schema_definition_nodes.any?
+        if !@schema_definition_nodes.empty?
           add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
         end
       end

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

@@ -3,7 +3,7 @@ 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?
+        if (node.operation_type == 'query' || node.operation_type.nil?) && context.query.types.query_root.nil?
           add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
             'Schema is not configured for queries',
             nodes: node

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

@@ -16,15 +16,15 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = defn.arguments(context.query.context)
+        args = @context.query.types.arguments(defn)
         return if args.empty?
         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) }
+        required_argument_names = context.query.types.arguments(defn)
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.query.types.argument(defn, a.name) }
           .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names
-        if missing_names.any?
+        if !missing_names.empty?
           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,

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

@@ -26,7 +26,7 @@ module GraphQL
           context.directive_definition || context.field_definition
         end
 
-        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
+        parent_type = context.types.argument(defn, parent_name(parent, defn))
         parent_type ? parent_type.type.unwrap : nil
       end
 
@@ -34,7 +34,7 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = context.warden.arguments(parent_type)
+        required_fields = context.types.arguments(parent_type)
           .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
           .map!(&:graphql_name)
 
@@ -43,7 +43,7 @@ module GraphQL
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
+          missing_field_type = context.types.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,

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

@@ -3,7 +3,7 @@ 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?
+        if node.operation_type == "subscription" && context.types.subscription_root.nil?
           add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
             'Schema is not configured for subscriptions',
             nodes: node

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

@@ -21,7 +21,7 @@ module GraphQL
 
       DIRECTIVE_NODE_HOOKS.each do |method_name|
         define_method(method_name) do |node, parent|
-          if node.directives.any?
+          if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)

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

@@ -5,36 +5,27 @@ module GraphQL
       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]
-            ))
+          type = context.schema.type_from_ast(node.type, context: context)
+          if type.nil?
+            # This is handled by another validator
           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)
+            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["explanation"]
-                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],
-                ))
+            if !validation_result.valid?
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                error_message = first_problem["explanation"]
               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

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

@@ -4,7 +4,7 @@ module GraphQL
     module VariableNamesAreUnique
       def on_operation_definition(node, parent)
         var_defns = node.variables
-        if var_defns.any?
+        if !var_defns.empty?
           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|

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

@@ -21,7 +21,7 @@ module GraphQL
         end
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
-        if node_values.any?
+        if !node_values.empty?
           argument_owner = case parent
           when GraphQL::Language::Nodes::Field
             context.field_definition
@@ -65,7 +65,7 @@ module GraphQL
           end
         end
 
-        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
+        arg_defn = @types.argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
         # If the argument is non-null, but it was given a default value,

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

@@ -4,11 +4,20 @@ module GraphQL
     module VariablesAreInputTypes
       def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
-        type = context.warden.get_type(type_name)
+        type = context.query.types.type(type_name)
 
         if type.nil?
+          @all_possible_input_type_names ||= begin
+            names = []
+            context.types.all_types.each { |(t)|
+              if t.kind.input?
+                names << t.graphql_name
+              end
+            }
+            names
+          end
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type_name} isn't a defined input type (on $#{node.name})",
+            "#{type_name} isn't a defined input type (on $#{node.name})#{context.did_you_mean_suggestion(type_name, @all_possible_input_type_names)}",
             nodes: node,
             name: node.name,
             type: type_name

data/lib/graphql/static_validation/validation_context.rb

@@ -13,14 +13,14 @@ module GraphQL
 
       attr_reader :query, :errors, :visitor,
         :on_dependency_resolve_handlers,
-        :max_errors, :warden, :schema
+        :max_errors, :types, :schema
 
 
       def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
-        @warden = query.warden
+        @types = query.types # TODO update migrated callers to use this accessor
         @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
@@ -29,6 +29,7 @@ module GraphQL
         @visitor = visitor_class.new(document, self)
       end
 
+      # TODO stop using def_delegators because of Array allocations
       def_delegators :@visitor,
         :path, :type_definition, :field_definition, :argument_definition,
         :parent_type_definition, :directive_definition, :object_types, :dependencies
@@ -48,6 +49,21 @@ module GraphQL
       def schema_directives
         @schema_directives ||= schema.directives
       end
+
+      def did_you_mean_suggestion(name, options)
+        if did_you_mean = schema.did_you_mean
+          suggestions = did_you_mean::SpellChecker.new(dictionary: options).correct(name)
+          case suggestions.size
+          when 0
+            ""
+          when 1
+            " (Did you mean `#{suggestions.first}`?)"
+          else
+            last_sugg = suggestions.pop
+            " (Did you mean #{suggestions.map {|s| "`#{s}`"}.join(", ")} or `#{last_sugg}`?)"
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -166,11 +166,12 @@ module GraphQL
       #
       def setup_stream(channel, initial_event)
         topic = initial_event.topic
-        channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
+        event_stream = stream_event_name(initial_event)
+        channel.stream_from(event_stream, coder: @action_cable_coder) do |message|
           events_by_fingerprint = @events[topic]
           object = nil
           events_by_fingerprint.each do |_fingerprint, events|
-            if events.any? && events.first == initial_event
+            if !events.empty? && events.first == initial_event
               # The fingerprint has told us that this response should be shared by all subscribers,
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -28,9 +28,8 @@ module GraphQL
         end
 
         current_field = visitor.field_definition
-        apply_broadcastable(current_field)
-
         current_type = visitor.parent_type_definition
+        apply_broadcastable(current_type, current_field)
         if current_type.kind.interface?
           pt = @query.possible_types(current_type)
           pt.each do |object_type|
@@ -38,7 +37,7 @@ module GraphQL
             # Inherited fields would be exactly the same object;
             # only check fields that are overrides of the inherited one
             if ot_field && ot_field != current_field
-              apply_broadcastable(ot_field)
+              apply_broadcastable(object_type, ot_field)
             end
           end
         end
@@ -55,10 +54,16 @@ module GraphQL
       private
 
       # Modify `@subscription_broadcastable` based on `field_defn`'s configuration (and/or the default value)
-      def apply_broadcastable(field_defn)
+      def apply_broadcastable(owner_type, field_defn)
         current_field_broadcastable = field_defn.introspection? || field_defn.broadcastable?
+
+        if current_field_broadcastable.nil? && owner_type.respond_to?(:default_broadcastable?)
+          current_field_broadcastable = owner_type.default_broadcastable?
+        end
+
         case current_field_broadcastable
         when nil
+          query.logger.debug { "`broadcastable: nil` for field: #{field_defn.path}" }
           # If the value wasn't set, mix in the default value:
           # - If the default is false and the current value is true, make it false
           # - If the default is true and the current value is true, it stays true
@@ -66,6 +71,7 @@ module GraphQL
           # - If the default is true and the current value is false, keep it false
           @subscription_broadcastable = @subscription_broadcastable && @default_broadcastable
         when false
+          query.logger.debug { "`broadcastable: false` for field: #{field_defn.path}" }
           # One non-broadcastable field is enough to make the whole subscription non-broadcastable
           @subscription_broadcastable = false
         when true

data/lib/graphql/subscriptions/event.rb

@@ -137,7 +137,7 @@ module GraphQL
         end
 
         def get_arg_definition(arg_owner, arg_name, context)
-          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
+          context.types.argument(arg_owner, arg_name) || context.types.arguments(arg_owner).find { |v| v.keyword.to_s == arg_name }
         end
       end
     end