Merge pull request #5474 from rmosolgo/one-of-allow-all-hidden

Add allow_all_hidden, make it default for required: :nullable

Author: rmosolgo

lib/graphql/schema/validator/required_validator.rb

@@ -38,14 +38,15 @@ class RequiredValidator < Validator
         # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
         # @param argument [Symbol] An argument that is required for this field
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
+        def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
-            [argument]
+            [ argument ]
           else
             raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
           end
+          @allow_all_hidden = allow_all_hidden.nil? ? !!argument : allow_all_hidden
           @message = message
           super(**default_options)
         end
@@ -54,10 +55,17 @@ def validate(_object, context, value)
           fully_matched_conditions = 0
           partially_matched_conditions = 0
 
+          visible_keywords = context.types.arguments(@validated).map(&:keyword)
+          no_visible_conditions = true
+
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
+                if no_visible_conditions && visible_keywords.include?(one_of_condition)
+                  no_visible_conditions = false
+                end
+
                 if value.key?(one_of_condition)
                   fully_matched_conditions += 1
                 end
@@ -66,6 +74,9 @@ def validate(_object, context, value)
                 full_match = true
 
                 one_of_condition.each do |k|
+                  if no_visible_conditions && visible_keywords.include?(k)
+                    no_visible_conditions = false
+                  end
                   if value.key?(k)
                     any_match = true
                   else
@@ -88,6 +99,18 @@ def validate(_object, context, value)
             end
           end
 
+          if no_visible_conditions
+            if @allow_all_hidden
+              return nil
+            else
+              raise GraphQL::Error, <<~ERR
+                #{@validated.path} validates `required: ...` but all required arguments were hidden.
+
+                Update your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`
+              ERR
+            end
+          end
+
           if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else

spec/graphql/schema/validator/required_validator_spec.rb

@@ -33,10 +33,10 @@
       ]
     },
     {
-      name: "All options hidden",
-      config: { one_of: [:secret, :secret2] },
+      name: "All options hidden, allow_all_hidden: true",
+      config: { one_of: [:secret, :secret2], allow_all_hidden: true },
       cases: [
-        { query: "{ validated: multiValidated(a: 1, b: 2) }", result: nil, error_messages: ["multiValidated is missing a required argument."] },
+        { query: "{ validated: multiValidated(a: 1, b: 2) }", result: 3, error_messages: [] },
       ],
     },
     {
@@ -92,4 +92,87 @@
   ]
 
   build_tests(:required, Integer, expectations)
+
+
+  describe "when all arguments are hidden" do
+    class RequiredHiddenSchema < GraphQL::Schema
+      class BaseArgument < GraphQL::Schema::Argument
+        def initialize(*args, always_hidden: false, **kwargs, &block)
+          super(*args, **kwargs, &block)
+          @always_hidden = always_hidden
+        end
+
+        def visible?(ctx)
+          !@always_hidden
+        end
+      end
+
+      class BaseField < GraphQL::Schema::Field
+        argument_class(BaseArgument)
+      end
+
+      class Query < GraphQL::Schema::Object
+        field_class(BaseField)
+
+        field :one_argument, Int, fallback_value: 1 do
+          argument :a, Int, required: :nullable, always_hidden: true
+        end
+
+        field :two_arguments, Int, fallback_value: 2 do
+          validates required: { one_of: [:a, :b], allow_all_hidden: true }
+          argument :a, Int, required: false, always_hidden: true
+          argument :b, Int, required: false, always_hidden: true
+        end
+
+        field :two_arguments_error, Int, fallback_value: 2 do
+          validates required: { one_of: [:a, :b] }
+          argument :a, Int, required: false, always_hidden: true
+          argument :b, Int, required: false, always_hidden: true
+        end
+
+        field :three_arguments, Int, fallback_value: 3 do
+          validates required: { one_of: [:a, :b], allow_all_hidden: true }
+          argument :a, Int, required: false, always_hidden: true
+          argument :b, Int, required: false, always_hidden: true
+          argument :c, Int
+        end
+
+        field :four_arguments, Int, fallback_value: 4 do
+          validates required: { one_of: [[:a, :b], :c, :d], allow_all_hidden: true}
+          argument :a, Int, required: false, always_hidden: true
+          argument :b, Int, required: false, always_hidden: true
+          argument :c, Int, required: false, always_hidden: true
+          argument :d, Int, required: false, always_hidden: true
+        end
+      end
+
+      query(Query)
+      use GraphQL::Schema::Visibility
+    end
+
+    it "Doesn't require any of one_of to be present" do
+      result = RequiredHiddenSchema.execute("{ threeArguments(c: 5) }")
+      assert_equal 3, result["data"]["threeArguments"]
+
+      result = RequiredHiddenSchema.execute("{ twoArguments }")
+      assert_equal 2, result["data"]["twoArguments"]
+
+      err = assert_raises GraphQL::Error do
+        RequiredHiddenSchema.execute("{ twoArgumentsError }")
+      end
+
+      expected_message = "Query.twoArgumentsError validates `required: ...` but all required arguments were hidden.\n\nUpdate your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`\n"
+      assert_equal expected_message, err.message
+    end
+
+    it "doesn't require hidden arguments when required as a group" do
+      result = RequiredHiddenSchema.execute("{ fourArguments }")
+      assert_equal 4, result["data"]["fourArguments"]
+    end
+
+    it "Doesn't require hidden argument to be present" do
+      result = RequiredHiddenSchema.execute("{ oneArgument }")
+      assert_equal 1, result["data"]["oneArgument"]
+    end
+  end
 end