graphql 2.3.8 → 2.4.0

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -50,12 +50,27 @@ module GraphQL
           end
         end
 
+        # Call this method to provide a new comment; OR
+        # call it without an argument to get the comment
+        # @param new_comment [String]
+        # @return [String, nil]
+        def comment(new_comment = NOT_CONFIGURED)
+          if !NOT_CONFIGURED.equal?(new_comment)
+            @comment = new_comment
+          elsif defined?(@comment)
+            @comment
+          else
+            nil
+          end
+        end
+
         # This pushes some configurations _down_ the inheritance tree,
         # in order to prevent repetitive lookups at runtime.
         module ConfigurationExtension
           def inherited(child_class)
             child_class.introspection(introspection)
             child_class.description(description)
+            child_class.comment(nil)
             child_class.default_graphql_name = nil
 
             if defined?(@graphql_name) && @graphql_name && (self.name.nil? || graphql_name != default_graphql_name)

data/lib/graphql/schema/member/has_arguments.rb

@@ -135,7 +135,7 @@ module GraphQL
 
             def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
               warden = Warden.from_context(context)
-              skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+              skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
               for ancestor in ancestors
                 if ancestor.respond_to?(:own_arguments) &&
                   (a = ancestor.own_arguments[argument_name]) &&
@@ -198,15 +198,19 @@ module GraphQL
         end
 
         def all_argument_definitions
-          all_defns = own_arguments.values
-          all_defns.flatten!
-          all_defns
+          if own_arguments.any?
+            all_defns = own_arguments.values
+            all_defns.flatten!
+            all_defns
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
         end
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
         def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
-          if (arg_config = own_arguments[argument_name]) && ((context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)) || (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden)))
+          if (arg_config = own_arguments[argument_name]) && ((context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)) || (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden)))
             visible_arg || arg_config
           elsif defined?(@resolver_class) && @resolver_class
             @resolver_class.get_field_argument(argument_name, context)

data/lib/graphql/schema/member/has_fields.rb

@@ -99,7 +99,7 @@ module GraphQL
         module InterfaceMethods
           def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
-            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
@@ -121,7 +121,7 @@ module GraphQL
                   # Choose the most local definition that passes `.visible?` --
                   # stop checking for fields by name once one has been found.
                   if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
-                    visible_fields[field_name] = f
+                    visible_fields[field_name] = f.ensure_loaded
                   end
                 end
               end
@@ -135,14 +135,14 @@ module GraphQL
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             ancs = ancestors
-            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Visibility::Profile)
             i = 0
             while (ancestor = ancs[i])
               if ancestor.respond_to?(:own_fields) &&
                   visible_interface_implementation?(ancestor, context, warden) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
                   (skip_visible || (f_entry = Warden.visible_entry?(:visible_field?, f_entry, context, warden)))
-                return f_entry
+                return (skip_visible ? f_entry : f_entry.ensure_loaded)
               end
               i += 1
             end
@@ -161,7 +161,7 @@ module GraphQL
                   # Choose the most local definition that passes `.visible?` --
                   # stop checking for fields by name once one has been found.
                   if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
-                    visible_fields[field_name] = f
+                    visible_fields[field_name] = f.ensure_loaded
                   end
                 end
               end

data/lib/graphql/schema/member/has_unresolved_type_error.rb

@@ -7,7 +7,11 @@ module GraphQL
       module HasUnresolvedTypeError
         private
         def add_unresolved_type_error(child_class)
-          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+          if child_class.name # Don't set this for anonymous classes
+            child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+          else
+            child_class.const_set(:UnresolvedTypeError, UnresolvedTypeError)
+          end
         end
       end
     end

data/lib/graphql/schema/printer.rb

@@ -58,6 +58,7 @@ module GraphQL
           end
         end
         schema = Class.new(GraphQL::Schema) {
+          use GraphQL::Schema::Visibility
           query(query_root)
           def self.visible?(member, _ctx)
             member.graphql_name != "Root"

data/lib/graphql/schema/resolver.rb

@@ -8,6 +8,7 @@ module GraphQL
     # - Arguments, via `.argument(...)` helper, which will be applied to the field.
     # - Return type, via `.type(..., null: ...)`, which will be applied to the field.
     # - Description, via `.description(...)`, which will be applied to the field
+    # - Comment, via `.comment(...)`, which will be applied to the field
     # - Resolution, via `#resolve(**args)` method, which will be called to resolve the field.
     # - `#object` and `#context` accessors for use during `#resolve`.
     #
@@ -19,7 +20,7 @@ module GraphQL
     # @see {GraphQL::Function} `Resolver` is a replacement for `GraphQL::Function`
     class Resolver
       include Schema::Member::GraphQLTypeNames
-      # Really we only need description from here, but:
+      # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasValidators
@@ -408,9 +409,7 @@ module GraphQL
 
         private
 
-        def own_extensions
-          @own_extensions
-        end
+        attr_reader :own_extensions
       end
     end
   end

data/lib/graphql/schema/validator/all_validator.rb

@@ -28,6 +28,8 @@ module GraphQL
         end
 
         def validate(object, context, value)
+          return EMPTY_ARRAY if permitted_empty_value?(value)
+
           all_errors = EMPTY_ARRAY
 
           value.each do |subvalue|

data/lib/graphql/schema/validator/required_validator.rb

@@ -35,9 +35,10 @@ module GraphQL
       #   end
       #
       class RequiredValidator < Validator
-        # @param one_of [Symbol, Array<Symbol>] An argument, or a list of arguments, that represents a valid set of inputs for this field
+        # @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: "%{validated} has the wrong arguments", **default_options)
+        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
@@ -49,7 +50,7 @@ module GraphQL
           super(**default_options)
         end
 
-        def validate(_object, _context, value)
+        def validate(_object, context, value)
           matched_conditions = 0
 
           if !value.nil?
@@ -73,9 +74,32 @@ module GraphQL
           if matched_conditions == 1
             nil # OK
           else
-            @message
+            @message || build_message(context)
           end
         end
+
+        def build_message(context)
+          argument_definitions = @validated.arguments(context).values
+          required_names = @one_of.map do |arg_keyword|
+            if arg_keyword.is_a?(Array)
+              names = arg_keyword.map { |arg| arg_keyword_to_grapqhl_name(argument_definitions, arg) }
+              "(" + names.join(" and ") + ")"
+            else
+              arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+            end
+          end
+
+          if required_names.size == 1
+            "%{validated} must include the following argument: #{required_names.first}."
+          else
+            "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
+          end
+        end
+
+        def arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+          argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
+          argument_definition.graphql_name
+        end
       end
     end
   end

data/lib/graphql/schema/visibility/migration.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Visibility
+      # You can use this to see how {GraphQL::Schema::Warden} and {GraphQL::Schema::Visibility::Profile}
+      # handle `.visible?` differently in your schema.
+      #
+      # It runs the same method on both implementations and raises an error when the results diverge.
+      #
+      # To fix the error, modify your schema so that both implementations return the same thing.
+      # Or, open an issue on GitHub to discuss the difference.
+      #
+      # This plugin adds overhead to runtime and may cause unexpected crashes -- **don't** use it in production!
+      #
+      # This plugin adds two keys to `context` when running:
+      #
+      # - `visibility_migration_running: true`
+      # - For the {Schema::Warden} which it instantiates, it adds `visibility_migration_warden_running: true`.
+      #
+      # Use those keys to modify your `visible?` behavior as needed.
+      #
+      # Also, in a pinch, you can set `skip_visibility_migration_error: true` in context to turn off this behavior per-query.
+      # (In that case, it uses {Profile} directly.)
+      #
+      # @example Adding this plugin
+      #
+      #   use GraphQL::Schema::Visibility, migration_errors: true
+      #
+      class Migration < GraphQL::Schema::Visibility::Profile
+        class RuntimeTypesMismatchError < GraphQL::Error
+          def initialize(method_called, warden_result, profile_result, method_args)
+            super(<<~ERR)
+              Mismatch in types for `##{method_called}(#{method_args.map(&:inspect).join(", ")})`:
+
+              #{compare_results(warden_result, profile_result)}
+
+              Update your `.visible?` implementation to make these implementations return the same value.
+
+              See: https://graphql-ruby.org/authorization/visibility_migration.html
+            ERR
+          end
+
+          private
+          def compare_results(warden_result, profile_result)
+            if warden_result.is_a?(Array) && profile_result.is_a?(Array)
+              all_results = warden_result | profile_result
+              all_results.sort_by!(&:graphql_name)
+
+              entries_text = all_results.map { |entry| "#{entry.graphql_name} (#{entry})"}
+              width = entries_text.map(&:size).max
+              yes = "    ✔   "
+              no =  "        "
+              res = "".dup
+              res << "#{"Result".center(width)} Warden  Profile \n"
+              all_results.each_with_index do |entry, idx|
+                res << "#{entries_text[idx].ljust(width)}#{warden_result.include?(entry) ? yes : no}#{profile_result.include?(entry) ? yes : no}\n"
+              end
+              res << "\n"
+            else
+              "- Warden returned: #{humanize(warden_result)}\n\n- Visibility::Profile returned: #{humanize(profile_result)}"
+            end
+          end
+          def humanize(val)
+            case val
+            when Array
+              "#{val.size}: #{val.map { |v| humanize(v) }.sort.inspect}"
+            when Module
+              if val.respond_to?(:graphql_name)
+                "#{val.graphql_name} (#{val.inspect})"
+              else
+                val.inspect
+              end
+            else
+              val.inspect
+            end
+          end
+        end
+
+        def initialize(context:, schema:, name: nil)
+          @name = name
+          @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema)
+          if !@skip_error
+            context[:visibility_migration_running] = true
+            warden_ctx_vals = context.to_h.dup
+            warden_ctx_vals[:visibility_migration_warden_running] = true
+            if schema.const_defined?(:WardenCompatSchema, false) # don't use a defn from a superclass
+              warden_schema = schema.const_get(:WardenCompatSchema, false)
+            else
+              warden_schema = Class.new(schema)
+              warden_schema.use_visibility_profile = false
+              # TODO public API
+              warden_schema.send(:add_type_and_traverse, [warden_schema.query, warden_schema.mutation, warden_schema.subscription].compact, root: true)
+              warden_schema.send(:add_type_and_traverse, warden_schema.directives.values + warden_schema.orphan_types, root: false)
+              schema.const_set(:WardenCompatSchema, warden_schema)
+            end
+            warden_ctx = GraphQL::Query::Context.new(query: context.query, values: warden_ctx_vals)
+            warden_ctx.warden = GraphQL::Schema::Warden.new(schema: warden_schema, context: warden_ctx)
+            warden_ctx.warden.skip_warning = true
+            warden_ctx.types = @warden_types = warden_ctx.warden.visibility_profile
+          end
+        end
+
+        def loaded_types
+          @profile_types.loaded_types
+        end
+
+        PUBLIC_PROFILE_METHODS = [
+          :enum_values,
+          :interfaces,
+          :all_types,
+          :all_types_h,
+          :fields,
+          :loadable?,
+          :type,
+          :arguments,
+          :argument,
+          :directive_exists?,
+          :directives,
+          :field,
+          :query_root,
+          :mutation_root,
+          :possible_types,
+          :subscription_root,
+          :reachable_type?
+        ]
+
+        PUBLIC_PROFILE_METHODS.each do |profile_method|
+          define_method(profile_method) do |*args|
+            call_method_and_compare(profile_method, args)
+          end
+        end
+
+        def call_method_and_compare(method, args)
+          res_1 = @profile_types.public_send(method, *args)
+          if @skip_error
+            return res_1
+          end
+
+          res_2 = @warden_types.public_send(method, *args)
+          normalized_res_1 = res_1.is_a?(Array) ? Set.new(res_1) : res_1
+          normalized_res_2 = res_2.is_a?(Array) ? Set.new(res_2) : res_2
+          if !equivalent_schema_members?(normalized_res_1, normalized_res_2)
+            # Raise the errors with the orignally returned values:
+            err = RuntimeTypesMismatchError.new(method, res_2, res_1, args)
+            raise err
+          else
+            res_1
+          end
+        end
+
+        def equivalent_schema_members?(member1, member2)
+          if member1.class != member2.class
+            return false
+          end
+
+          case member1
+          when Set
+            member1_array = member1.to_a.sort_by(&:graphql_name)
+            member2_array = member2.to_a.sort_by(&:graphql_name)
+            member1_array.each_with_index do |inner_member1, idx|
+              inner_member2 = member2_array[idx]
+              equivalent_schema_members?(inner_member1, inner_member2)
+            end
+          when GraphQL::Schema::Field
+            member1.ensure_loaded
+            member2.ensure_loaded
+            if member1.introspection? && member2.introspection?
+              member1.inspect == member2.inspect
+            else
+              member1 == member2
+            end
+          when Module
+            if member1.introspection? && member2.introspection?
+              member1.graphql_name == member2.graphql_name
+            else
+              member1 == member2
+            end
+          else
+            member1 == member2
+          end
+        end
+      end
+    end
+  end
+end