feat(Mask) implement hidden enum values

Author: rmosolgo

lib/graphql/introspection/enum_values_field.rb

@@ -2,11 +2,16 @@
   type types[!GraphQL::Introspection::EnumValueType]
   argument :includeDeprecated, types.Boolean, default_value: false
   resolve ->(object, arguments, context) do
-    return nil if !object.kind.enum?
-    fields = object.values.values
-    if !arguments["includeDeprecated"]
-      fields = fields.select {|f| !f.deprecation_reason }
+    if !object.kind.enum?
+      nil
+    else
+      enum_values = context.warden.each_enum_value(object).to_a
+
+      if !arguments["includeDeprecated"]
+        enum_values = enum_values.select {|f| !f.deprecation_reason }
+      end
+
+      enum_values
     end
-    fields
   end
 end

lib/graphql/schema/mask.rb

@@ -10,11 +10,7 @@ def apply(query)
       end
 
       def visible?(member)
-        !hidden?(member)
-      end
-
-      def hidden?(member)
-        !!@filter.call(member)
+        !@filter.call(member)
       end
 
       # A Mask implementation that shows everything as visible
@@ -28,15 +24,11 @@ def apply(query)
         def visible?(member)
           true
         end
-
-        def hidden?(member)
-          false
-        end
       end
 
       # Restrict access to `@schema`'s members based on `@mask` & `@query`'s context
       class Warden
-        # @param mask [<#hidden?(member), #visible?(member)>]
+        # @param mask [<#visible?(member)>]
         # @param query [GraphQL::Query]
         def initialize(mask, query)
           @mask = mask
@@ -110,13 +102,15 @@ def each_argument(argument_owner)
         end
 
         # @yieldparam [GraphQL::EnumType::EnumValue] Each member of `enum_defn`
-        def each_value(enum_defn)
+        def each_enum_value(enum_defn)
           if block_given?
             enum_defn.values.each do |name, enum_value_defn|
-              yield(enum_value_defn)
+              if visible_enum_value?(enum_value_defn)
+                yield(enum_value_defn)
+              end
             end
           else
-            enum_for(:enum_defn, enum_defn)
+            enum_for(:each_enum_value, enum_defn)
           end
         end
 
@@ -136,24 +130,16 @@ def each_interface(obj_type)
 
         private
 
-        def hidden_field?(field_defn)
-          hidden?(field_defn) || hidden?(field_defn.type.unwrap)
-        end
-
         def visible_field?(field_defn)
-          !hidden_field?(field_defn)
-        end
-
-        def hidden_type?(type_defn)
-          hidden?(type_defn)
+          visible?(field_defn) && visible?(field_defn.type.unwrap)
         end
 
         def visible_type?(type_defn)
-          !hidden_type?(type_defn)
+          visible?(type_defn)
         end
 
-        def hidden?(member)
-          @mask.hidden?(member)
+        def visible_enum_value?(enum_value_defn)
+          visible?(enum_value_defn)
         end
 
         def visible?(member)

lib/graphql/static_validation/literal_validator.rb

@@ -2,6 +2,10 @@ module GraphQL
   module StaticValidation
     # Test whether `ast_value` is a valid input for `type`
     class LiteralValidator
+      def initialize(warden:)
+        @warden = warden
+      end
+
       def validate(ast_value, type)
         if type.kind.non_null?
           (!ast_value.nil?) && validate(ast_value, type.of_type)
@@ -11,7 +15,8 @@ def validate(ast_value, type)
         elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
           type.valid_input?(ast_value)
         elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-          type.valid_input?(ast_value.name)
+          # TODO: this shortcuts the `valid_input?` API, should I improve that API instead of bypassing it?
+          @warden.each_enum_value(type).find { |enum_value_defn| enum_value_defn.name == ast_value.name }
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           required_input_fields_are_present(type, ast_value) &&
             present_input_field_values_are_valid(type, ast_value)

lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -3,11 +3,9 @@ module StaticValidation
     class ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
       def validate_node(parent, node, defn, context)
         return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-        validator = GraphQL::StaticValidation::LiteralValidator.new
         arg_defn = defn.arguments[node.name]
         return unless arg_defn
-        valid = validator.validate(node.value, arg_defn.type)
-        if !valid
+        if !context.valid_literal?(node.value, arg_defn.type)
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
           context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.", parent, context: context)

lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -4,21 +4,20 @@ class VariableDefaultValuesAreCorrectlyTyped
       include GraphQL::StaticValidation::Message::MessageHelper
 
       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)
+            validate_default_value(node, context)
           end
         }
       end
 
-      def validate_default_value(node, literal_validator, context)
+      def validate_default_value(node, 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, context: context)
         else
           type = context.schema.type_from_ast(node.type)
-          if !literal_validator.validate(value, type)
+          if !context.valid_literal?(value, type)
             context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node, context: context)
           end
         end

lib/graphql/static_validation/validation_context.rb

@@ -70,6 +70,11 @@ def argument_definition
         @type_stack.argument_definitions[-2]
       end
 
+      def valid_literal?(ast_value, type)
+        @literal_validator ||= LiteralValidator.new(warden: @warden)
+        @literal_validator.validate(ast_value, type)
+      end
+
       # Don't try to validate dynamic fields
       # since they aren't defined by the type system
       def skip_field?(field_name)

spec/graphql/schema/mask_spec.rb

@@ -10,6 +10,20 @@ module MaskHelpers
     field :name, types.String.to_non_null_type
     field :symbol, types.String.to_non_null_type
     field :languages, LanguageType.to_list_type
+    field :manner, MannerEnum
+  end
+
+  MannerEnum = GraphQL::EnumType.define do
+    name "Manner"
+    description "Manner of articulation for this sound"
+    value "STOP"
+    value "AFFRICATE"
+    value "FRICATIVE"
+    value "APPROXIMANT"
+    value "VOWEL"
+    value "TRILL" do
+      metadata :hidden_enum_value, true
+    end
   end
 
   LanguageType = GraphQL::ObjectType.define do
@@ -50,7 +64,11 @@ module MaskHelpers
       metadata :hidden_field, true
       argument :name, !types.String
     end
-    field :phonemes, PhonemeType.to_list_type
+
+    field :phonemes, PhonemeType.to_list_type do
+      argument :manners, MannerEnum.to_list_type, "Filter phonemes by manner of articulation"
+    end
+
     field :phoneme, PhonemeType do
       description "Lookup a phoneme by symbol"
       argument :symbol, !types.String
@@ -235,9 +253,51 @@ def get_recursive_field_type_names(field_result)
     it "isn't a valid input"
   end
 
-  describe "#hidden_enum_value?" do
-    it "isn't present in introspection"
-    it "isn't a valid return value"
-    it "isn't a valid input"
+  describe "hiding enum values" do
+    let(:mask) {
+      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_enum_value] }
+    }
+
+    it "isn't present in introspection" do
+      query_string = %|
+      {
+        Manner: __type(name: "Manner") { enumValues { name } }
+        __schema {
+          types {
+            enumValues { name }
+          }
+        }
+      }
+      |
+
+      res = MaskHelpers.query_with_mask(query_string, mask)
+
+      manner_values = res["data"]["Manner"]["enumValues"]
+        .map { |v| v["name"] }
+
+      schema_values = res["data"]["__schema"]["types"]
+        .map { |t| t["enumValues"] || [] }
+        .flatten
+        .map { |v| v["name"] }
+
+      refute_includes manner_values, "TRILL", "It's not present on __type"
+      refute_includes schema_values, "TRILL", "It's not present in __schema"
+    end
+
+    it "isn't a valid input" do
+      query_string = %|
+      { phonemes(manners: [STOP, TRILL]) { symbol } }
+      |
+      res = MaskHelpers.query_with_mask(query_string, mask)
+      # It's not a good error message ... but it's something!
+      expected_errors = [{
+        "message" => "Argument 'manners' on Field 'phonemes' has an invalid value. Expected type '[Manner]'.",
+        "locations" => [{"line"=>2, "column"=>9}],
+        "fields" => ["query", "phonemes", "manners"]
+      }]
+      assert_equal expected_errors, res["errors"]
+    end
+
+    it "returns nil in a query response"
   end
 end