graphql 2.5.11 → 2.5.19

data/lib/graphql/execution/interpreter/runtime.rb

@@ -35,11 +35,10 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, lazies_at_depth:)
+        def initialize(query:)
           @query = query
           @current_trace = query.current_trace
           @dataloader = query.multiplex.dataloader
-          @lazies_at_depth = lazies_at_depth
           @schema = query.schema
           @context = query.context
           @response = nil
@@ -365,6 +364,10 @@ module GraphQL
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
               runtime_state = get_current_runtime_state # This might be in a different fiber
+              runtime_state.current_field = field_defn
+              runtime_state.current_arguments = resolved_arguments
+              runtime_state.current_result_name = result_name
+              runtime_state.current_result = selections_result
               evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
             end
           end
@@ -373,6 +376,8 @@ module GraphQL
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              next if selection_result.collect_result(result_name, resolved_arguments)
+
               return_type_non_null = field_defn.type.non_null?
               continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -446,7 +451,7 @@ module GraphQL
             }
           end
 
-          field_result = call_method_on_directives(:resolve, object, directives) do
+          call_method_on_directives(:resolve, object, directives) do
             if !directives.empty?
               # This might be executed in a different context; reset this info
               runtime_state = get_current_runtime_state
@@ -472,6 +477,8 @@ module GraphQL
             end
             @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
+              next if selection_result.collect_result(result_name, inner_result)
+
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
               continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -488,7 +495,7 @@ module GraphQL
           # all of its child fields before moving on to the next root mutation field.
           # (Subselections of this mutation will still be resolved level-by-level.)
           if selection_result.graphql_is_eager
-            Interpreter::Resolve.resolve_all([field_result], @dataloader)
+            @dataloader.run
           end
         end
 
@@ -667,7 +674,11 @@ module GraphQL
             rescue GraphQL::ExecutionError => ex_err
               return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
             rescue StandardError => err
-              query.handle_or_reraise(err)
+              begin
+                query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+              end
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
@@ -879,7 +890,6 @@ module GraphQL
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
-            orig_result = result
             was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
               # This block might be called in a new fiber;
@@ -889,13 +899,13 @@ module GraphQL
               runtime_state.current_field = field
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name
-              runtime_state.current_result = orig_result
+              runtime_state.current_result = result
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
-              result = nil
+              sync_result = nil
               inner_obj = begin
-                result = if trace
+                sync_result = if trace
                   @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
@@ -913,7 +923,7 @@ module GraphQL
                 end
               ensure
                 if trace
-                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, sync_result)
                 end
               end
               yield(inner_obj, runtime_state)
@@ -923,12 +933,7 @@ module GraphQL
               lazy.value
             else
               set_result(result, result_name, lazy, false, false) # is_non_null is irrelevant here
-              current_depth = 0
-              while result
-                current_depth += 1
-                result = result.graphql_parent
-              end
-              @lazies_at_depth[current_depth] << lazy
+              @dataloader.lazy_at_depth(result.depth, lazy)
               lazy
             end
           else

data/lib/graphql/execution/interpreter.rb

@@ -42,7 +42,6 @@ module GraphQL
           trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
@@ -73,7 +72,7 @@ module GraphQL
                       # Although queries in a multiplex _share_ an Interpreter instance,
                       # they also have another item of state, which is private to that query
                       # in particular, assign it here:
-                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
                       query.current_trace.execute_query(query: query) do
@@ -81,23 +80,13 @@ module GraphQL
                       end
                     rescue GraphQL::ExecutionError => err
                       query.context.errors << err
-                      NO_OPERATION
                     end
                   end
                   results[idx] = result
                 }
               end
 
-              multiplex.dataloader.run
-
-              # Then, work through lazy results in a breadth-first way
-              multiplex.dataloader.append_job {
-                query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                end
-              }
-              multiplex.dataloader.run
+              multiplex.dataloader.run(trace_query_lazy: multiplex)
 
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|

data/lib/graphql/language/document_from_schema_definition.rb

@@ -52,8 +52,9 @@ module GraphQL
 
       def build_object_type_node(object_type)
         ints = @types.interfaces(object_type)
+
         if !ints.empty?
-          ints.sort_by!(&:graphql_name)
+          ints = ints.sort_by(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
         end
 

data/lib/graphql/language.rb

@@ -77,21 +77,30 @@ module GraphQL
       new_query_str || query_str
     end
 
+    LEADING_REGEX = Regexp.union(" ", *Lexer::Punctuation.constants.map { |const| Lexer::Punctuation.const_get(const) })
+
+    # Optimized pattern using:
+    # - Possessive quantifiers (*+, ++) to prevent backtracking in number patterns
+    # - Atomic group (?>...) for IGNORE to prevent backtracking
+    # - Single unified number pattern instead of three alternatives
+    EFFICIENT_NUMBER_REGEXP = /-?(?:0|[1-9][0-9]*+)(?:\.[0-9]++)?(?:[eE][+-]?[0-9]++)?/
+    EFFICIENT_IGNORE_REGEXP = /(?>[, \r\n\t]+|\#[^\n]*$)*/
+
+    MAYBE_INVALID_NUMBER = /\d[_a-zA-Z]/
+
     INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP = %r{
-      (
-        ((?<num>#{Lexer::INT_REGEXP}(#{Lexer::FLOAT_EXP_REGEXP})?)(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-        |
-        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP}#{Lexer::FLOAT_EXP_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-        |
-        ((?<num>#{Lexer::INT_REGEXP}#{Lexer::FLOAT_DECIMAL_REGEXP})(?<name>#{Lexer::IDENTIFIER_REGEXP})#{Lexer::IGNORE_REGEXP}:)
-      )}x
+      (?<leading>#{LEADING_REGEX})
+      (?<num>#{EFFICIENT_NUMBER_REGEXP})
+      (?<name>#{Lexer::IDENTIFIER_REGEXP})
+      #{EFFICIENT_IGNORE_REGEXP}
+      :
+    }x
 
     def self.add_space_between_numbers_and_names(query_str)
-      if query_str.match?(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP)
-        query_str.gsub(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP, "\\k<num> \\k<name>:")
-      else
-        query_str
-      end
+      # Fast check for digit followed by identifier char. If this doesn't match, skip the more expensive regexp entirely.
+      return query_str unless query_str.match?(MAYBE_INVALID_NUMBER)
+      return query_str unless query_str.match?(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP)
+      query_str.gsub(INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP, "\\k<leading>\\k<num> \\k<name>:")
     end
   end
 end

data/lib/graphql/schema/argument.rb

@@ -39,9 +39,14 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
+      # @param type [Class, Array<Class>] Input type; positional argument also accepted
+      # @param name [Symbol] positional argument also accepted        # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
+      # @param definition_block [Proc] Called with the newly-created {Argument}
+      # @param owner [Class] Private, used by GraphQL-Ruby during schema definition
       # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
+      # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
@@ -50,6 +55,8 @@ module GraphQL
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
+      # @param comment [String] Private, used by GraphQL-Ruby when parsing GraphQL schema files
+      # @param ast_node [GraphQL::Language::Nodes::InputValueDefinition] Private, used by GraphQL-Ruby when parsing schema files
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)

data/lib/graphql/schema/build_from_definition.rb

@@ -266,6 +266,8 @@ module GraphQL
             build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
             build_input_object_type(definition, type_resolver, base_types[:input_object])
+          when GraphQL::Language::Nodes::DirectiveDefinition
+            build_directive(definition, type_resolver)
           end
         end
 
@@ -544,7 +546,7 @@ module GraphQL
             when GraphQL::Language::Nodes::ListType
               resolve_type_proc.call(ast_node.of_type).to_list_type
             when String
-              directives[ast_node]
+              directives[ast_node] ||= missing_type_handler.call(ast_node)
             else
               raise "Unexpected ast_node: #{ast_node.inspect}"
             end

data/lib/graphql/schema/directive.rb

@@ -129,11 +129,29 @@ module GraphQL
         # not runtime arguments.
         context = Query::NullContext.instance
         self.class.all_argument_definitions.each do |arg_defn|
-          if arguments.key?(arg_defn.keyword)
-            value = arguments[arg_defn.keyword]
+          keyword = arg_defn.keyword
+          arg_type = arg_defn.type
+          if arguments.key?(keyword)
+            value = arguments[keyword]
             # This is a Ruby-land value; convert it to graphql for validation
             graphql_value = begin
-              arg_defn.type.unwrap.coerce_isolated_result(value)
+              coerce_value = value
+              if arg_type.list? && (!coerce_value.nil?) && (!coerce_value.is_a?(Array))
+                # When validating inputs, GraphQL accepts a single item
+                # and implicitly converts it to a one-item list.
+                # However, we're using result coercion here to go from Ruby value
+                # to GraphQL value, so it doesn't have that feature.
+                # Keep the GraphQL-type behavior but implement it manually:
+                wrap_type = arg_type
+                while wrap_type.list?
+                  if wrap_type.non_null?
+                    wrap_type = wrap_type.of_type
+                  end
+                  wrap_type = wrap_type.of_type
+                  coerce_value = [coerce_value]
+                end
+              end
+              arg_type.coerce_isolated_result(coerce_value)
             rescue GraphQL::Schema::Enum::UnresolvedValueError
               # Let validation handle this
               value
@@ -142,7 +160,7 @@ module GraphQL
             value = graphql_value = nil
           end
 
-          result = arg_defn.type.validate_input(graphql_value, context)
+          result = arg_type.validate_input(graphql_value, context)
           if !result.valid?
             raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
           end

data/lib/graphql/schema/field.rb

@@ -109,52 +109,6 @@ module GraphQL
       end
       attr_writer :subscription_scope
 
-      # Create a field instance from a list of arguments, keyword arguments, and a block.
-      #
-      # This method implements prioritization between the `resolver` or `mutation` defaults
-      # and the local overrides via other keywords.
-      #
-      # It also normalizes positional arguments into keywords for {Schema::Field#initialize}.
-      # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
-      # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
-      # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration
-      # @return [GraphQL::Schema:Field] an instance of `self`
-      # @see {.initialize} for other options
-      def self.from_options(name = nil, type = nil, desc = nil, comment: nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
-        if (resolver_class = resolver || mutation || subscription)
-          # Add a reference to that parent class
-          kwargs[:resolver_class] = resolver_class
-        end
-
-        if name
-          kwargs[:name] = name
-        end
-
-        if comment
-          kwargs[:comment] = comment
-        end
-
-        if !type.nil?
-          if desc
-            if kwargs[:description]
-              raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})"
-            end
-
-            kwargs[:description] = desc
-            kwargs[:type] = type
-          elsif (resolver || mutation) && type.is_a?(String)
-            # The return type should be copied from the resolver, and the second positional argument is the description
-            kwargs[:description] = type
-          else
-            kwargs[:type] = type
-          end
-          if type.is_a?(Class) && type < GraphQL::Schema::Mutation
-            raise ArgumentError, "Use `field #{name.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
-          end
-        end
-        new(**kwargs, &block)
-      end
-
       # Can be set with `connection: true|false` or inferred from a type name ending in `*Connection`
       # @return [Boolean] if true, this field will be wrapped with Relay connection behavior
       def connection?
@@ -255,6 +209,11 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @param fallback_value [Object] A fallback value if the method is not defined
+      # @param dynamic_introspection [Boolean] (Private, used by GraphQL-Ruby)
+      # @param relay_node_field [Boolean] (Private, used by GraphQL-Ruby)
+      # @param relay_nodes_field [Boolean] (Private, used by GraphQL-Ruby)
+      # @param extras [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] Extra arguments to be injected into the resolver for this field
+      # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}.
       def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, comment: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
@@ -347,7 +306,7 @@ module GraphQL
 
         @extensions = EMPTY_ARRAY
         @call_after_define = false
-        set_pagination_extensions(connection_extension: connection_extension)
+        set_pagination_extensions(connection_extension: NOT_CONFIGURED.equal?(connection_extension) ? self.class.connection_extension : connection_extension)
         # Do this last so we have as much context as possible when initializing them:
         if !extensions.empty?
           self.extensions(extensions)

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

@@ -14,29 +14,52 @@ module GraphQL
           cls.extend(ClassConfigured)
         end
 
-        # @see {GraphQL::Schema::Argument#initialize} for parameters
-        # @return [GraphQL::Schema::Argument] An instance of {argument_class}, created from `*args`
-        def argument(*args, **kwargs, &block)
-          kwargs[:owner] = self
-          loads = kwargs[:loads]
-          if loads
-            name = args[0]
-            name_as_string = name.to_s
-
-            inferred_arg_name = case name_as_string
+        # @param arg_name [Symbol] The underscore-cased name of this argument, `name:` keyword also accepted
+        # @param type_expr The GraphQL type of this argument; `type:` keyword also accepted
+        # @param desc [String] Argument description, `description:` keyword also accepted
+        # @option kwargs [Boolean, :nullable] :required if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
+        # @option kwargs [String] :description Positional argument also accepted
+        # @option kwargs [Class, Array<Class>] :type Input type; positional argument also accepted
+        # @option kwargs [Symbol] :name positional argument also accepted
+        # @option kwargs [Object] :default_value
+        # @option kwargs [Class, Array<Class>] :loads A GraphQL type to load for the given ID when one is present
+        # @option kwargs [Symbol] :as Override the keyword name when passed to a method
+        # @option kwargs [Symbol] :prepare A method to call to transform this argument's valuebefore sending it to field resolution
+        # @option kwargs [Boolean] :camelize if true, the name will be camelized when building the schema
+        # @option kwargs [Boolean] :from_resolver if true, a Resolver class defined this argument
+        # @option kwargs [Hash{Class => Hash}] :directives
+        # @option kwargs [String] :deprecation_reason
+        # @option kwargs [String] :comment Private, used by GraphQL-Ruby when parsing GraphQL schema files
+        # @option kwargs [GraphQL::Language::Nodes::InputValueDefinition] :ast_node Private, used by GraphQL-Ruby when parsing schema files
+        # @option kwargs [Hash, nil] :validates Options for building validators, if any should be applied
+        # @option kwargs [Boolean] :replace_null_with_default if `true`, incoming values of `null` will be replaced with the configured `default_value`
+        # @param definition_block [Proc] Called with the newly-created {Argument}
+        # @param kwargs [Hash] Keywords for defining an argument. Any keywords not documented here must be handled by your base Argument class.
+        # @return [GraphQL::Schema::Argument] An instance of {argument_class} created from these arguments
+        def argument(arg_name = nil, type_expr = nil, desc = nil, **kwargs, &definition_block)
+          if kwargs[:loads]
+            loads_name = arg_name || kwargs[:name]
+            loads_name_as_string = loads_name.to_s
+
+            inferred_arg_name = case loads_name_as_string
             when /_id$/
-              name_as_string.sub(/_id$/, "").to_sym
+              loads_name_as_string.sub(/_id$/, "").to_sym
             when /_ids$/
-              name_as_string.sub(/_ids$/, "")
+              loads_name_as_string.sub(/_ids$/, "")
                 .sub(/([^s])$/, "\\1s")
                 .to_sym
             else
-              name
+              loads_name
             end
 
             kwargs[:as] ||= inferred_arg_name
           end
-          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          arg_defn = self.argument_class.new(
+            arg_name, type_expr, desc,
+            **kwargs,
+            &definition_block
+          )
           add_argument(arg_defn)
           arg_defn
         end
@@ -413,6 +436,12 @@ module GraphQL
             end
           end
 
+          # Called when an argument's `loads:` configuration fails to fetch an application object.
+          # By default, this method raises the given error, but you can override it to handle failures differently.
+          #
+          # @param err [GraphQL::LoadApplicationObjectFailedError] The error that occurred
+          # @return [Object, nil] If a value is returned, it will be used instead of the failed load
+          # @api public
           def load_application_object_failed(err)
             raise err
           end

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

@@ -5,11 +5,83 @@ module GraphQL
     class Member
       # Shared code for Objects, Interfaces, Mutations, Subscriptions
       module HasFields
+        include EmptyObjects
         # Add a field to this object or interface with the given definition
-        # @see {GraphQL::Schema::Field#initialize} for method signature
+        # @param name_positional [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API); `name:` keyword is also accepted
+        # @param type_positional [Class, GraphQL::BaseType, Array] The return type of this field; `type:` keyword is also accepted
+        # @param desc_positional [String] Field description; `description:` keyword is also accepted
+        # @option kwargs [Symbol] :name The underscore-cased version of this field name (will be camelized for the GraphQL API); positional argument also accepted
+        # @option kwargs [Class, GraphQL::BaseType, Array] :type The return type of this field; positional argument is also accepted
+        # @option kwargs [Boolean] :null (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null`
+        # @option kwargs [String] :description Field description; positional argument also accepted
+        # @option kwargs [String] :comment Field comment
+        # @option kwargs [String] :deprecation_reason If present, the field is marked "deprecated" with this message
+        # @option kwargs [Symbol] :method The method to call on the underlying object to resolve this field (defaults to `name`)
+        # @option kwargs [String, Symbol] :hash_key The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+        # @option kwargs [Array<String, Symbol>] :dig The nested hash keys to lookup on the underlying hash to resolve this field using dig
+        # @option kwargs [Symbol] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
+        # @option kwargs [Boolean] :connection `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
+        # @option kwargs [Class] :connection_extension The extension to add, to implement connections. If `nil`, no extension is added.
+        # @option kwargs [Integer, nil] :max_page_size For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
+        # @option kwargs [Integer, nil] :default_page_size For connections, the default number of items to return from this field, or `nil` to return unlimited results.
+        # @option kwargs [Boolean] :introspection If true, this field will be marked as `#introspection?` and the name may begin with `__`
+        # @option kwargs [{String=>GraphQL::Schema::Argument, Hash}] :arguments Arguments for this field (may be added in the block, also)
+        # @option kwargs [Boolean] :camelize If true, the field name will be camelized when building the schema
+        # @option kwargs [Numeric] :complexity When provided, set the complexity for this field
+        # @option kwargs [Boolean] :scope If true, the return type's `.scope_items` method will be called on the return value
+        # @option kwargs [Symbol, String] :subscription_scope A key in `context` which will be used to scope subscription payloads
+        # @option kwargs [Array<Class, Hash<Class => Object>>] :extensions Named extensions to apply to this field (see also {#extension})
+        # @option kwargs [Hash{Class => Hash}] :directives Directives to apply to this field
+        # @option kwargs [Boolean] :trace If true, a {GraphQL::Tracing} tracer will measure this scalar field
+        # @option kwargs [Boolean] :broadcastable Whether or not this field can be distributed in subscription broadcasts
+        # @option kwargs [Language::Nodes::FieldDefinition, nil] :ast_node If this schema was parsed from definition, this AST node defined the field
+        # @option kwargs [Boolean] :method_conflict_warning If false, skip the warning if this field's method conflicts with a built-in method
+        # @option kwargs [Array<Hash>] :validates Configurations for validating this field
+        # @option kwargs [Object] :fallback_value A fallback value if the method is not defined
+        # @option kwargs [Class<GraphQL::Schema::Mutation>] :mutation
+        # @option kwargs [Class<GraphQL::Schema::Resolver>] :resolver
+        # @option kwargs [Class<GraphQL::Schema::Subscription>] :subscription
+        # @option kwargs [Boolean] :dynamic_introspection (Private, used by GraphQL-Ruby)
+        # @option kwargs [Boolean] :relay_node_field (Private, used by GraphQL-Ruby)
+        # @option kwargs [Boolean] :relay_nodes_field (Private, used by GraphQL-Ruby)
+        # @option kwargs [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] :extras Extra arguments to be injected into the resolver for this field
+        # @param kwargs [Hash] Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled.
+        # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}.
+        # @yieldparam field [GraphQL::Schema::Field] The newly-created field instance
+        # @yieldreturn [void]
         # @return [GraphQL::Schema::Field]
-        def field(*args, **kwargs, &block)
-          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
+        def field(name_positional = nil, type_positional = nil, desc_positional = nil, **kwargs, &definition_block)
+          resolver = kwargs.delete(:resolver)
+          mutation = kwargs.delete(:mutation)
+          subscription = kwargs.delete(:subscription)
+          if (resolver_class = resolver || mutation || subscription)
+            # Add a reference to that parent class
+            kwargs[:resolver_class] = resolver_class
+          end
+
+          kwargs[:name] ||= name_positional
+          if !type_positional.nil?
+            if desc_positional
+              if kwargs[:description]
+                raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc_positional.inspect}, #{kwargs[:description].inspect})"
+              end
+
+              kwargs[:description] = desc_positional
+              kwargs[:type] = type_positional
+            elsif (resolver || mutation) && type_positional.is_a?(String)
+              # The return type should be copied from the resolver, and the second positional argument is the description
+              kwargs[:description] = type_positional
+            else
+              kwargs[:type] = type_positional
+            end
+
+            if type_positional.is_a?(Class) && type_positional < GraphQL::Schema::Mutation
+              raise ArgumentError, "Use `field #{name_positional.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
+            end
+          end
+
+          kwargs[:owner] = self
+          field_defn = field_class.new(**kwargs, &definition_block)
           add_field(field_defn)
           field_defn
         end
@@ -232,7 +304,7 @@ module GraphQL
           end
         end
 
-        # @param [GraphQL::Schema::Field]
+        # @param field_defn [GraphQL::Schema::Field]
         # @return [String] A warning to give when this field definition might conflict with a built-in method
         def conflict_field_name_warning(field_defn)
           "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."

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

@@ -8,6 +8,13 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
+      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # skip validation in this case instead.
+      #
+      # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
+      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      #
       # @example Require exactly one of these arguments
       #
       #   field :update_amount, IngredientAmount, null: false do
@@ -37,15 +44,17 @@ module GraphQL
       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 allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
         # @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 +63,17 @@ module GraphQL
           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 +82,9 @@ module GraphQL
                 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 +107,18 @@ module GraphQL
             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

data/lib/graphql/schema/visibility.rb

@@ -10,9 +10,9 @@ module GraphQL
     class Visibility
       # @param schema [Class<GraphQL::Schema>]
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
-      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
+      # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?` and `Rails.env.staging?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? (Rails.env.production? || Rails.env.staging?) : nil), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze