graphql 1.11.1 → 1.11.6

data/lib/graphql/schema/input_object.rb

@@ -126,9 +126,11 @@ module GraphQL
           argument_defn = super(*args, **kwargs, &block)
           # Add a method access
           method_name = argument_defn.keyword
-          define_method(method_name) do
-            self[method_name]
-          end
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
         end
 
         def to_graphql
@@ -166,10 +168,7 @@ module GraphQL
             return result
           end
 
-          # We're not actually _using_ the coerced result, we're just
-          # using these methods to make sure that the object will
-          # behave like a hash below, when we call `each` on it.
-          begin
+          input = begin
             input.to_h
           rescue
             begin
@@ -182,21 +181,25 @@ module GraphQL
             end
           end
 
-          visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
-
-          # Items in the input that are unexpected
-          input.each do |name, value|
-            if visible_arguments_map[name].nil?
-              result.add_problem("Field is not defined on #{self.graphql_name}", [name])
+          # Inject missing required arguments
+          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
+            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
+              m[argument_name] = nil
             end
+
+            m
           end
 
-          # Items in the input that are expected, but have invalid values
-          visible_arguments_map.map do |name, argument|
-            argument_result = argument.type.validate_input(input[name], ctx)
-            if !argument_result.valid?
-              result.merge_result!(name, argument_result)
+          input.merge(missing_required_inputs).each do |argument_name, value|
+            argument = warden.get_argument(self, argument_name)
+            # Items in the input that are unexpected
+            unless argument
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+              next
             end
+            # Items in the input that are expected, but have invalid values
+            argument_result = argument.type.validate_input(value, ctx)
+            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result

data/lib/graphql/schema/interface.rb

@@ -30,7 +30,7 @@ module GraphQL
 
         # The interface is accessible if any of its possible types are accessible
         def accessible?(context)
-          context.schema.possible_types(self).each do |type|
+          context.schema.possible_types(self, context).each do |type|
             if context.schema.accessible?(type, context)
               return true
             end

data/lib/graphql/schema/late_bound_type.rb

@@ -16,11 +16,11 @@ module GraphQL
       end
 
       def to_non_null_type
-        GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
       end
 
       def to_list_type
-        GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::ListType.new(of_type: self)
       end
 
       def inspect

data/lib/graphql/schema/loader.rb

@@ -25,8 +25,15 @@ module GraphQL
           types[type["name"]] = type_object
         end
 
+        directives = []
+        schema.fetch("directives", []).each do |directive|
+          next if GraphQL::Schema.default_directives.include?(directive.fetch("name"))
+          directives << define_directive(directive, type_resolver)
+        end
+
         Class.new(GraphQL::Schema) do
           orphan_types(types.values)
+          directives(directives)
 
           def self.resolve_type(*)
             raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
@@ -98,7 +105,7 @@ module GraphQL
                 value(
                   enum_value["name"],
                   description: enum_value["description"],
-                  deprecation_reason: enum_value["deprecation_reason"],
+                  deprecation_reason: enum_value["deprecationReason"],
                 )
               end
             end
@@ -147,6 +154,16 @@ module GraphQL
           end
         end
 
+        def define_directive(directive, type_resolver)
+          loader = self
+          Class.new(GraphQL::Schema::Directive) do
+            graphql_name(directive["name"])
+            description(directive["description"])
+            locations(*directive["locations"].map(&:to_sym))
+            loader.build_arguments(self, directive["args"], type_resolver)
+          end
+        end
+
         public
 
         def build_fields(type_defn, fields, type_resolver)
@@ -156,6 +173,7 @@ module GraphQL
               field_hash["name"],
               type: type_resolver.call(field_hash["type"]),
               description: field_hash["description"],
+              deprecation_reason: field_hash["deprecationReason"],
               null: true,
               camelize: false,
             ) do
@@ -171,6 +189,7 @@ module GraphQL
             kwargs = {
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
               required: false,
               method_access: false,
               camelize: false,

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

@@ -4,6 +4,10 @@ module GraphQL
     class Member
       # @api private
       module BuildType
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function
@@ -162,10 +166,16 @@ module GraphQL
         end
 
         def underscore(string)
-          string
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-            .downcase
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
         end
       end
     end

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

@@ -43,6 +43,7 @@ module GraphQL
         # @param arg_defn [GraphQL::Schema::Argument]
         # @return [GraphQL::Schema::Argument]
         def add_argument(arg_defn)
+          @own_arguments ||= {}
           own_arguments[arg_defn.name] = arg_defn
           arg_defn
         end
@@ -58,6 +59,22 @@ module GraphQL
           end
         end
 
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        def get_argument(argument_name)
+          a = own_arguments[argument_name]
+
+          if a || !self.is_a?(Class)
+            a
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
+                return a
+              end
+            end
+            nil
+          end
+        end
+
         # @param new_arg_class [Class] A class to use for building argument definitions
         def argument_class(new_arg_class = nil)
           self.class.argument_class(new_arg_class)
@@ -213,8 +230,9 @@ module GraphQL
           end
         end
 
+        NO_ARGUMENTS = {}.freeze
         def own_arguments
-          @own_arguments ||= {}
+          @own_arguments || NO_ARGUMENTS
         end
       end
     end

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

@@ -47,20 +47,22 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method, :raw_value]
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.
         #
         # @api private
-        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS)
+        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods)
 
         # Register this field with the class, overriding a previous one if needed.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
-        def add_field(field_defn)
-          if CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.method_conflict_warning?
-            warn "#{self.graphql_name}'s `field :#{field_defn.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."
+        def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
+          # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
+          # that shows that no override value was given manually.
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+            warn(conflict_field_name_warning(field_defn))
           end
           own_fields[field_defn.name] = field_defn
           nil
@@ -80,9 +82,9 @@ module GraphQL
           end
         end
 
-        def global_id_field(field_name)
+        def global_id_field(field_name, **kwargs)
           id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
-          field field_name, "ID", null: false
+          field field_name, "ID", **kwargs, null: false
           define_method(field_name) do
             id_resolver.call(object, {}, context)
           end
@@ -92,6 +94,14 @@ module GraphQL
         def own_fields
           @own_fields ||= {}
         end
+
+        private
+
+        # @param [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."
+        end
       end
     end
   end

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

@@ -6,12 +6,12 @@ module GraphQL
       module TypeSystemHelpers
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          GraphQL::Schema::NonNull.new(self)
+          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          GraphQL::Schema::List.new(self)
+          @to_list_type ||= GraphQL::Schema::List.new(self)
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

data/lib/graphql/schema/mutation.rb

@@ -78,6 +78,10 @@ module GraphQL
 
         private
 
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `hash_key:` or `method:` to pick a different resolve behavior for this field (for example, `hash_key: :#{field_defn.resolver_method}_value`, and modify the return hash). Or use `method_conflict_warning: false` to suppress this warning."
+        end
+
         # Override this to attach self as `mutation`
         def generate_payload_type
           payload_class = super

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -122,7 +122,9 @@ module GraphQL
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            own_arguments.merge!(mutation_args)
+            mutation_args.each do |_name, arg|
+              add_argument(arg)
+            end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
           end
         end

data/lib/graphql/schema/resolver.rb

@@ -40,6 +40,7 @@ module GraphQL
           @arguments_by_keyword[arg.keyword] = arg
         end
         @arguments_loads_as_type = self.class.arguments_loads_as_type
+        @prepared_arguments = nil
       end
 
       # @return [Object] The application object this field is being resolved on
@@ -51,6 +52,10 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      def arguments
+        @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
+      end
+
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.
@@ -74,6 +79,7 @@ module GraphQL
             # for that argument, or may return a lazy object
             load_arguments_val = load_arguments(args)
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
+              @prepared_arguments = loaded_args
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
                 authorized?(**loaded_args)

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -58,7 +58,8 @@ module GraphQL
             resolver_fields.each do |name, f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              add_field(f)
+              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+              add_field(f, method_conflict_warning: false)
             end
           end
         end

data/lib/graphql/schema/subscription.rb

@@ -12,16 +12,6 @@ module GraphQL
     #
     # Also, `#unsubscribe` terminates the subscription.
     class Subscription < GraphQL::Schema::Resolver
-      class EarlyTerminationError < StandardError
-      end
-
-      # Raised when `unsubscribe` is called; caught by `subscriptions.rb`
-      class UnsubscribedError < EarlyTerminationError
-      end
-
-      # Raised when `no_update` is returned; caught by `subscriptions.rb`
-      class NoUpdateError < EarlyTerminationError
-      end
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
 
@@ -65,7 +55,7 @@ module GraphQL
       def resolve_update(**args)
         ret_val = args.any? ? update(**args) : update
         if ret_val == :no_update
-          raise NoUpdateError
+          throw :graphql_no_subscription_update
         else
           ret_val
         end
@@ -90,7 +80,7 @@ module GraphQL
 
       # Call this to halt execution and remove this subscription from the system
       def unsubscribe
-        raise UnsubscribedError
+        throw :graphql_subscription_unsubscribed
       end
 
       READING_SCOPE = ::Object.new

data/lib/graphql/schema/timeout.rb

@@ -7,7 +7,7 @@ module GraphQL
     # to the `errors` key. Any already-resolved fields will be in the `data` key, so
     # you'll get a partial response.
     #
-    # You can subclass `GraphQL::Schema::Timeout` and override the `handle_timeout` method
+    # You can subclass `GraphQL::Schema::Timeout` and override `max_seconds` and/or `handle_timeout`
     # to provide custom logic when a timeout error occurs.
     #
     # Note that this will stop a query _in between_ field resolutions, but
@@ -33,8 +33,6 @@ module GraphQL
     #   end
     #
     class Timeout
-      attr_reader :max_seconds
-
       def self.use(schema, **options)
         tracer = new(**options)
         schema.tracer(tracer)
@@ -48,32 +46,39 @@ module GraphQL
       def trace(key, data)
         case key
         when 'execute_multiplex'
-          timeout_state = {
-            timeout_at: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) + max_seconds * 1000,
-            timed_out: false
-          }
-
           data.fetch(:multiplex).queries.each do |query|
+            timeout_duration_s = max_seconds(query)
+            timeout_state = if timeout_duration_s == false
+              # if the method returns `false`, don't apply a timeout
+              false
+            else
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+              timeout_at = now + (max_seconds(query) * 1000)
+              {
+                timeout_at: timeout_at,
+                timed_out: false
+              }
+            end
             query.context.namespace(self.class)[:state] = timeout_state
           end
 
           yield
         when 'execute_field', 'execute_field_lazy'
-          query = data[:context] ? data.fetch(:context).query : data.fetch(:query)
-          timeout_state = query.context.namespace(self.class).fetch(:state)
-          if Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+          query_context = data[:context] || data[:query].context
+          timeout_state = query_context.namespace(self.class).fetch(:state)
+          # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
+          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             error = if data[:context]
-              context = data.fetch(:context)
-              GraphQL::Schema::Timeout::TimeoutError.new(context.parent_type, context.field)
+              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
             else
               field = data.fetch(:field)
               GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
             end
 
             # Only invoke the timeout callback for the first timeout
-            unless timeout_state[:timed_out]
+            if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query)
+              handle_timeout(error, query_context.query)
             end
 
             error
@@ -85,6 +90,15 @@ module GraphQL
         end
       end
 
+      # Called at the start of each query.
+      # The default implementation returns the `max_seconds:` value from installing this plugin.
+      #
+      # @param query [GraphQL::Query] The query that's about to run
+      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      def max_seconds(query)
+        @max_seconds
+      end
+
       # Invoked when a query times out.
       # @param error [GraphQL::Schema::Timeout::TimeoutError]
       # @param query [GraphQL::Error]