refactor(Query) take except: instead of mask:

Author: rmosolgo

lib/graphql/query.rb

@@ -17,6 +17,14 @@ def initialize(names)
       end
     end
 
+    module NullExcept
+      module_function
+
+      def call(member)
+        false
+      end
+    end
+
     attr_reader :schema, :document, :context, :fragments, :operations, :root_value, :max_depth, :query_string, :warden
 
     # Prepare query `query_string` on `schema`
@@ -28,12 +36,12 @@ def initialize(names)
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param mask [Schema::Mask] A mask for this query
-    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, mask: GraphQL::Schema::Mask::NullMask)
+    # @param except [<#call(schema_member)>] If provided, objects will be hidden from the schema when `.call(schema_member)` returns truthy
+    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: NullExcept)
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
       @schema = schema
-      @warden = GraphQL::Schema::Warden.new(schema, mask)
+      @warden = GraphQL::Schema::Warden.new(schema, except)
       @max_depth = max_depth || schema.max_depth
       @max_complexity = max_complexity || schema.max_complexity
       @query_analyzers = schema.query_analyzers.dup

lib/graphql/schema.rb

@@ -1,6 +1,5 @@
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/invalid_type_error"
-require "graphql/schema/mask"
 require "graphql/schema/middleware_chain"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"

lib/graphql/schema/mask.rb

@@ -9,10 +9,35 @@ class Schema
     # you may show a client something that it shouldn't be allowed to see.
     #
     # Masks can be provided in {Schema#execute} (or {Query#initialize}) with the `mask:` keyword.
-    # @see [GraphQL::Schema::Mask] A built-in mask implementation.
+    #
+    # @example Hidding private fields
+    #   private_members = -> (member) { member.metadata[:private] }
+    #   result = Schema.execute(query_string, except: private_members)
+    #
+    # @example Custom mask implementation
+    #   # It must respond to `#call(member)`.
+    #   class MissingRequiredFlags
+    #     def initialize(user)
+    #       @user = user
+    #     end
+    #
+    #     # Return `false` if any required flags are missing
+    #     def call(member)
+    #       member.metadata[:required_flags].any? do |flag|
+    #         [email protected]_flag?(flag)
+    #       end
+    #     end
+    #   end
+    #
+    #   # Then, use the custom filter in query:
+    #   missing_required_flags = MissingRequiredFlags.new(current_user)
+    #
+    #   # This query can only access members which match the user's flags
+    #   result = Schema.execute(query_string, except: missing_required_flags)
+    #
     class Warden
       # @param schema [GraphQL::Schema]
-      # @param mask [<#visible?(member)>] This object controls access to schema members
+      # @param mask [<#call(member)>] Objects are hidden when `.call(member)` returns true
       def initialize(schema, mask)
         @mask = mask
         @schema = schema
@@ -79,7 +104,7 @@ def visible_field?(field_defn)
       end
 
       def visible?(member)
-        @mask.visible?(member)
+        !@mask.call(member)
       end
     end
   end

lib/graphql/schema/warden.rb

@@ -106,12 +106,12 @@ def self.unit
   end
 
   def self.query_with_mask(str, mask)
-    Schema.execute(str, mask: mask, root_value: Data)
+    Schema.execute(str, except: mask, root_value: Data)
   end
 end
 
 
-describe GraphQL::Schema::Mask do
+describe GraphQL::Schema::Warden do
   def type_names(introspection_result)
     introspection_result["data"]["__schema"]["types"].map { |t| t["name"] }
   end
@@ -144,11 +144,9 @@ def error_messages(query_result)
     query_result["errors"].map { |err| err["message"] }
   end
 
-  let(:warden) { mask.apply(GraphQL::Query.new(MaskHelpers::Schema, "{ __typename }")) }
-
   describe "hiding fields" do
     let(:mask) {
-      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_field] || member.metadata[:hidden_type] }
+      -> (member) { member.metadata[:hidden_field] || member.metadata[:hidden_type] }
     }
 
     it "causes validation errors" do
@@ -194,7 +192,7 @@ def error_messages(query_result)
 
   describe "hiding types" do
     let(:mask) {
-      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_type] }
+      -> (member) { member.metadata[:hidden_type] }
     }
 
     it "hides types from introspection" do
@@ -280,7 +278,7 @@ def error_messages(query_result)
 
     describe "hiding an abstract type" do
       let(:mask) {
-        GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_abstract_type] }
+        -> (member) { member.metadata[:hidden_abstract_type] }
       }
 
       it "isn't present in a type's interfaces" do
@@ -302,7 +300,7 @@ def error_messages(query_result)
 
   describe "hiding arguments" do
     let(:mask) {
-      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_argument] || member.metadata[:hidden_input_type] }
+      -> (member) { member.metadata[:hidden_argument] || member.metadata[:hidden_input_type] }
     }
 
     it "isn't present in introspection" do
@@ -338,7 +336,7 @@ def error_messages(query_result)
 
   describe "hidding input types" do
     let(:mask) {
-      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_input_object_type] }
+      -> (member) { member.metadata[:hidden_input_object_type] }
     }
 
     it "isn't present in introspection" do
@@ -383,7 +381,7 @@ def error_messages(query_result)
 
   describe "hiding enum values" do
     let(:mask) {
-      GraphQL::Schema::Mask.new { |member| member.metadata[:hidden_enum_value] }
+      -> (member) { member.metadata[:hidden_enum_value] }
     }
 
     it "isn't present in introspection" do